Note: This page has been translated by MathWorks. Please click here

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

To view all translated materals including this page, select Japan from the country navigator on the bottom of this page.

Time-dispersive channels can cause intersymbol interference (ISI), which is a form of distortion that causes symbols to overlap and become indistinguishable by the receiver. In a multipath scattering environment, the receiver sees delayed versions of a symbol transmission, which can interfere with other symbol transmissions. Equalizers attempt to mitigate ISI and improve the receiver performance.

The Communications
System Toolbox™ includes Simulink^{®} blocks, System objects, and MATLAB^{®} functions that provide equalization capabilities classified as
Adaptive or Maximum-Likelihood Sequence Estimation:

Adaptive equalizers include:

Symbol-spaced linear equalizers

Fractionally spaced linear equalizers (FSEs)

Decision-feedback equalizers (DFEs)

Maximum-Likelihood Sequence Estimation (MLSE) equalizers using the Viterbi algorithm. To explore MLSE equalizer capabilities, see MLSE Equalizers.

Linear and decision-feedback equalization can be performed using these various adaptive algorithms:

Least mean square (LMS)

Signed LMS -- including sign LMS, signed regressor LMS, and sign-sign LMS

Normalized LMS

Variable-step-size LMS

Recursive least squares (RLS)

Constant modulus algorithm (CMA)

Adaptive equalizer implementations provided in the Communications System Toolbox differ in the equalizer structure and the type of adaptive algorithm that they use. In all cases, you specify information about the equalizer structure (such as the number of taps), the adaptive algorithm (such as the step size), and the signal constellation used by the modulator in your design. You also specify an initial set of weights for the equalizer taps and the block adaptively updates the weights throughout the simulation. For adaptive algorithms other than CMA, the equalizer can adapt the weights in two modes: training mode and decision-directed mode.

To explore adaptive equalizer capabilities, see Adaptive Algorithms. For reference background material, see the works listed in Selected Bibliography for Equalizers.

To equalizing a signal using Communications System Toolbox software and MATLAB:

Create an equalizer object that specifies the desired equalizer class and the adaptive algorithm.

Adjust properties of the equalizer object, as desired to tailor it to your needs. An equalizer object allows you to specify settings for properties, such as the equalizer class, the adaptive algorithm, and the values of the weights.

Apply the equalizer object to the signal you want to equalize, using the

`equalize`

method of the equalizer object.

Create a BPSK modulator and an equalizer object.

hMod = comm.BPSKModulator; eqlms = lineareq(8,lms(0.03));

Change the reference tap index in the equalizer.

eqlms.RefTap = 4;

Build a set of test data. Receive the data by convolving the signal.

x = hMod(randi([0 1],1000,1)); rxsig = conv(x,[1 0.8 0.3]);

Apply the equalizer object to a signal.

y = equalize(eqlms,rxsig,x(1:200));

In this example, `eqlms`

is an equalizer object that describes a linear LMS equalizer having eight weights and a step size of `0.03`

. At first, the reference tap index in the equalizer has a default value, but assigning a new value to the property `eqlms.RefTap`

changes this index. Finally, the `equalize`

command uses the `eqlms`

object to equalize the signal `rxsig`

using the training sequence `x(1:200)`

.

A decision-feedback equalizer (DFE) is a nonlinear equalizer that contains a forward filter and a feedback filter. The forward filter is similar to the linear equalizer described in Symbol-Spaced Equalizers, while the feedback filter contains a tapped delay line whose inputs are the decisions made on the equalized signal. The purpose of a DFE is to cancel intersymbol interference while minimizing noise enhancement. By contrast, noise enhancement is a typical problem with the linear equalizers described earlier.

The following schematic contains a fractionally spaced DFE with
*L* forward weights and *N-L* feedback
weights. The forward filter is at the top and the feedback filter is at the
bottom. If *K* is 1, the result is a symbol-spaced DFE instead
of a fractionally spaced DFE.

In each symbol period, the equalizer receives *K* input
samples at the forward filter, as well as one decision or training sample at the
feedback filter. The equalizer then outputs a weighted sum of the values in the
forward and feedback delay lines, and updates the weights to prepare for the
next symbol period.

The algorithm for the Weight Setting block in the schematic
*jointly* optimizes the forward and feedback weights.
Joint optimization is especially important for the RLS algorithm.

A symbol-spaced linear equalizer consists of a tapped delay line that stores
samples from the input signal. Once per symbol period, the equalizer outputs a
weighted sum of the values in the delay line and updates the weights to prepare
for the next symbol period. This class of equalizer is called
*symbol-spaced* because the sample rates of the input and
output are equal.

Below is a schematic of a symbol-spaced linear equalizer with
*N* weights and the symbol period of
*T*.

**Updating the Set of Weights. **The algorithms for the Weight Setting and Error Calculation blocks in the
schematic are determined by the adaptive algorithm chosen from the list in
Equalization Features.
The new set of weights depends on these quantities:

The current set of weights

The input signal

The output signal

For adaptive algorithms other than CMA, a reference signal, d, whose characteristics depend on the operation mode of the equalizer

**Reference Signal and Operation Modes. **The table below briefly describes the nature of the reference signal for
each of the two operation modes.

Operation Mode of Equalizer | Reference Signal |
---|---|

Training mode | Preset known transmitted sequence |

Decision-directed mode | Detected version of the output signal, denoted by
y_{d} in the
schematic |

In typical applications, the equalizer begins in training mode to gather information about the channel, and later switches to decision-directed mode.

**Error Calculation. **The error calculation operation produces a signal given by the expression
below, where *R* is a constant related to the signal constellation.

$$e=\{\begin{array}{cc}d-y& \text{AlgorithmsotherthanCMA}\\ y(R-{\left|y\right|}^{2})& \text{CMA}\end{array}$$

A fractionally spaced equalizer is a linear equalizer that is similar to a symbol-spaced linear equalizer, as described in Symbol-Spaced Equalizers. By contrast, however, a fractionally spaced equalizer receives K input samples before it produces one output sample and updates the weights, where K is an integer. In many applications, K is 2. The output sample rate is 1/T, while the input sample rate is K/T. The weight-updating occurs at the output rate, which is the slower rate.

The following schematic illustrates a fractionally spaced equalizer.

This model shows the behavior of least mean square (LMS) and recursive least square (RLS) adaptive equalizers in a communication link with a fading channel. The transmitter and receiver have root raised cosine pulse shaped filtering.

**Structure of the model**

The transmitter generates 16QAM random signal data which includes a training sequence and applies root raised cosine pulse shaped filtering.

Channel impairments include multipath fading, Doppler shift, carrier frequency offset, variable integer delay, free space path loss, and AWGN.

The receiver applies root raised cosine pulse shaped filtering, AGC, includes equalizer mode control to enable training and allows you to select the equalizer algorithm from these choices:

The model also uses scopes that can help you understand how different algorithms behave.

**Explore Example Model**

**Experimenting with the model**

This model provides several ways for you to change settings and observe the results. The `InitFcn`

found in `File>Model Properties>Callbacks`

calls `slex_adaptive_eq_with_fading_init`

to initialize the model. This file enables you to vary settings in the model, including:

System parameters, such as SNR

Pulse shaping filter parameters, such as rolloff and filter length

Path loss value

Channel conditions: Rayleigh or Rician fading, channel path gains, channel path delays, Doppler shift

Equalizer choice and parameters

**Model Considerations**

This non-standards-based communication link is representative of a modern communications system.

The optimal equalizer configuration is dependent on the channel conditions. The initialization file sets the Doppler shift and multipath fading channel parameters that highlight the capabilities of different equalizers.

The LMS algorithm executes quickly but converges slowly, and its complexity grows linearly with the number of weights.

The RLS algorithm converges quickly, but its complexity grows with the square of the number of weights, roughly speaking. This algorithm can also be unstable when the number of weights is large.

The channel exercised for different equalizers have the following characteristics:

Initial settings for other channel impairments are the same for all equalizers. Carrier frequency offset value is set to 50 Hz. Free space path loss is set to 60 dB. Variable integer delay is set to 2 samples, which requires the equalizers to perform some timing recovery.

The `AGC`

block adjusts the magnitude of received signal to counter the signal level variation from the channel impairments, particularly the path loss. The optimal AGC output power level must be adjusted based on the modulation scheme selected. For 16QAM, a desired output power of 10 W is used.

Training of the equalizer is performed:

At the beginning of the simulation

If the number of symbol errors for a given frame exceeds a preset threshold

The threshold is set to 10 for this model. The equalizer mode control block gets feedback on the number of errors and decides based on this information, whether the equalizer should be trained or decision directed. The `Error Rate Calculation`

block generates the error rate data needed by the equalizer mode control.

**Running the Simulation**

Running the simulation produces these figures:

A constellation diagram of the signal after the receive filter

A constellation diagram of the signal after AGC

A constellation diagram of the signal after equalization with signal quality measurements shown

An equalizer error plot

For the plots shown here the equalizer algorithm selected is `RLS Linear`

. Monitoring these figures, you can see that the received signal quality fluctuates as simulation time progresses. If the error threshold is exceeded, the equalizer reenters training mode.

**Equalization Training**

Throughout the simulation, the signal before equalization deviates noticeably from a 16QAM signal constellation. At the start of the simulation, the equalizer weights have not converged and constellation after equalization is poor. In the `Eq Error`

plot, at approximately 1 ms the equalizer converges. Between 5 and 6 ms the channel conditions cause the `Equalizer Mode Control`

to switch back to training mode.

After some simulation time passes, the equalizer weighting reconverges and the recovered signal error count stays below the retraining threshold for the remainder of the simulation run.

The *After AGC* diagram show the constellation before equalization. It shows the impact of the channel conditions on the transmitted signal. The signal plotted in the constellation diagram after equalization shows the variation in signal quality based on the effectiveness of the equalization process.

**Further Exploration**

Double-click the `Equalizer Selector`

block and select a different equalizer. Run the simulation to see performance of the various equalizer options. You can use the signal logger to compare the results from this experimentation. Right-click on signal wires in the block diagram and select Log Selected Signals.

At the MATLAB™ command prompt, enter `edit slex_adaptive_eq_with_fading_init.m`

to open the initialization file, then modify a parameter and rerun the simulation. If you have enabled signal logging, after the simulation run finishes, open the Simulation Data Inspector to view the logged signals. For example:

Adjust the error threshold (

`params.trngErrorThreshold`

). Decreasing the error threshold increases the frequency of equalizer weight recomputations, which results in a lower symbol error rate but higher processing burden. Increasing the error threshold decreases the frequency of equalizer weight recomputations, which results in a lower processing burden but a higher overall symbol error rate.

This section provides an overview of the process you typically use in the MATLAB environment to take advantage of the adaptive equalizer capabilities. The MLSE equalizer has a different interface, described in MLSE Equalizers.

Keeping the basic procedure in mind, read other portions of this chapter to learn more details about

How to create objects that represent different classes of adaptive equalizers and different adaptive algorithms

How to adjust properties of an adaptive equalizer or properties of an adaptive algorithm

How to equalize signals using an adaptive equalizer object

**Choose an Adaptive Algorithm. **Configuring an equalizer involves choosing an adaptive algorithm and
indicating your choice when creating an equalizer object in the MATLAB environment.

The best choice of adaptive algorithm might depend on your individual situation. Consider these generalizations when deciding which adaptive algorithm best fits your needs:

The LMS algorithm executes quickly but converges slowly, and its complexity grows linearly with the number of weights.

The RLS algorithm converges quickly, but its complexity grows with the square of the number of weights, roughly speaking. This algorithm can also be unstable when the number of weights is large.

The various types of signed LMS algorithms simplify hardware implementation.

The normalized LMS and variable-step-size LMS algorithms are more robust to variability of the input signal's statistics (such as power).

The constant modulus algorithm is useful when no training signal is available, and works best for constant modulus modulations such as PSK.

### Note

If CMA has no additional side information, it can introduce phase ambiguity. For example, CMA might find weights that produce a perfect QPSK constellation but might introduce a phase rotation of 90, 180, or 270 degrees. Alternatively, differential modulation can be used to avoid phase ambiguity.

Details about the adaptive algorithms are in the references listed in Selected Bibliography for Equalizers.

**Indicating a Choice of Adaptive Algorithm. **After you have chosen the adaptive algorithm you want to use, indicate
your choice when creating the equalizer object mentioned in Equalize A Signal. The functions
listed in the table below provide a way to indicate your choice of adaptive
algorithm.

Adaptive Algorithm Function | Type of Adaptive Algorithm |
---|---|

`lms` | Least mean square (LMS) |

`signlms` | Signed LMS, signed regressor LMS, sign-sign LMS |

`normlms` | Normalized LMS |

`varlms` | Variable-step-size LMS |

`rls` | Recursive least squares (RLS) |

`cma` | Constant modulus algorithm (CMA) |

Two typical ways to use a function from the table are as follows:

Use the function in an inline expression when creating the equalizer object.

For example, the code below uses the

`lms`

function inline when creating an equalizer object.eqlms = lineareq(10,lms(0.003));

Use the function to create a variable in the MATLAB workspace and then use that variable when creating the equalizer object. The variable is called an

*adaptive algorithm object*.For example, the code below creates an adaptive algorithm object named

`alg`

that represents the adaptive algorithm, and then uses`alg`

when creating an equalizer object.alg = lms(0.003); eqlms = lineareq(10,alg);

### Note

To create an adaptive algorithm object by duplicating an existing one and then changing its properties, see the important note in Duplicating and Copying Objects about the use of

`copy`

versus the`=`

operator.

In practice, the two ways are equivalent when your goal is to create an equalizer object or to equalize a signal.

**Access Properties of an Adaptive Algorithm. **The adaptive algorithm functions not only provide a way to indicate your
choice of adaptive algorithm, but they also let you specify certain
properties of the algorithm. For information about what each property of an
adaptive algorithm object means, see the reference pages for the `lms`

, `signlms`

, `normlms`

, `varlms`

, `rls`

, or `cma`

functions.

To view or change any properties of an adaptive algorithm, use the syntax described for channel objects in Displaying and Changing Object Properties.

**Defining an Equalizer Object. **To create an equalizer object, use one of the functions listed in the
table below.

Function | Type of Equalizer |
---|---|

`lineareq` | Linear equalizer (symbol-spaced or fractionally spaced) |

`dfe` | Decision-feedback equalizer |

For example, the code below creates three equalizer objects: one representing a symbol-spaced linear RLS equalizer having 10 weights, one representing a fractionally spaced linear RLS equalizer having 10 weights and two samples per symbol, and one representing a decision-feedback RLS equalizer having three weights in the feedforward filter and two weights in the feedback filter.

% Create equalizer objects of different types. eqlin = lineareq(10,rls(0.3)); % Symbol-spaced linear eqfrac = lineareq(10,rls(0.3),[-1 1],2); % Fractionally spaced linear eqdfe = dfe(3,2,rls(0.3)); % DFE

Although the `lineareq`

and `dfe`

functions have different syntaxes, they both require an input argument that
represents an adaptive algorithm. To learn how to represent an adaptive
algorithm or how to vary properties of the adaptive algorithm, see Specify an Adaptive Algorithm.

Each of the equalizer objects created above is a valid input argument for
the `equalize`

function. To learn how to use the
`equalize`

function to equalize a signal, see Using Adaptive Equalizers.

Another way to create an object is to duplicate an existing object and
then adjust the properties of the new object, if necessary. If you do
this, it is important that you use a `copy`

command
such as

c2 = copy(c1); % Copy c1 to create an independent c2.

instead of `c2 = c1`

. The `copy`

command creates a copy of `c1`

that is independent of
`c1`

. By contrast, the command ```
c2 =
c1
```

creates `c2`

as merely a reference to
`c1`

, so that `c1`

and
`c2`

always have indistinguishable content.

**Accessing Properties of an Equalizer. **An equalizer object has numerous properties that record information about
the equalizer. Properties can be related to

The structure of the equalizer (for example, the number of weights).

The adaptive algorithm that the equalizer uses (for example, the step size in the LMS algorithm). When you create the equalizer object using

`lineareq`

or`dfe`

, the function copies certain properties from the algorithm object to the equalizer object. However, the equalizer object does not retain a connection to the algorithm object.Information about the equalizer's current state (for example, the values of the weights). The

`equalize`

function automatically updates these properties when it operates on a signal.Instructions for operating on a signal (for example, whether the equalizer should reset itself before starting the equalization process).

For information about what each equalizer property means, see the
reference page for the `lineareq`

or `dfe`

function.

To view or change any properties of an equalizer object, use the syntax described for channel objects in Displaying and Changing Object Properties.

Some properties of an equalizer object are related to each other such
that when one property's value changes, another property's value must
adjust, or else the equalizer object fails to describe a valid
equalizer. For example, in a linear equalizer, the
`nWeights`

property is the number of weights, while
the `Weights`

property is the value of the weights. If
you change the value of `nWeights`

, the value of
`Weights`

must adjust so that its vector length is
the new value of `nWeights`

.

To find out which properties are related and how MATLAB compensates automatically when you make certain changes in
property values, see the reference page for `lineareq`

or `dfe`

.

The example below illustrates that when you change the value of
`nWeights`

, MATLAB automatically changes the values of
`Weights`

and `WeightInputs`

to make their vector lengths consistent with the new value of
`nWeights`

. Because the example uses the
variable-step-size LMS algorithm, `StepSize`

is a
vector (not a scalar) and MATLAB changes its vector length to maintain consistency with
the new value of `nWeights`

.

eqlvar = lineareq(10,varlms(0.01,0.01,0,1)) % Create equalizer object. eqlvar.nWeights = 8 % Change the number of weights from 10 to 8. % MATLAB automatically changes the sizes of eqlvar.Weights and % eqlvar.WeightInputs.

The output below displays all the properties of the equalizer
object before and after the change in the value of the
`nWeights`

property. In the second listing of
properties, the `nWeights`

,
`Weights`

, `WeightInputs`

, and
`StepSize`

properties all have different values
compared to the first listing of properties.

eqlvar = EqType: 'Linear Equalizer' AlgType: 'Variable Step Size LMS' nWeights: 10 nSampPerSym: 1 RefTap: 1 SigConst: [-1 1] InitStep: 0.0100 IncStep: 0.0100 MinStep: 0 MaxStep: 1 LeakageFactor: 1 StepSize: [1x10 double] Weights: [0 0 0 0 0 0 0 0 0 0] WeightInputs: [0 0 0 0 0 0 0 0 0 0] ResetBeforeFiltering: 1 NumSamplesProcessed: 0 eqlvar = EqType: 'Linear Equalizer' AlgType: 'Variable Step Size LMS' nWeights: 8 nSampPerSym: 1 RefTap: 1 SigConst: [-1 1] InitStep: 0.0100 IncStep: 0.0100 MinStep: 0 MaxStep: 1 LeakageFactor: 1 StepSize: [1x8 double] Weights: [0 0 0 0 0 0 0 0] WeightInputs: [0 0 0 0 0 0 0 0] ResetBeforeFiltering: 1 NumSamplesProcessed: 0

**Equalize Using a Training Sequence in MATLAB. **This section describes how to equalize a signal by using the
`equalize`

function to apply an adaptive equalizer
object to the signal. The `equalize`

function also
updates the equalizer. This section assumes that you have already created an
adaptive equalizer object, as described in Specify an Adaptive Equalizer.

For an example that complements this section, see the Adaptive Equalization example.

In typical applications, an equalizer begins by using a known sequence of
transmitted symbols when adapting the equalizer weights. The known sequence,
called a *training sequence*, enables the equalizer to
gather information about the channel characteristics. After the equalizer
finishes processing the training sequence, it adapts the equalizer weights
in decision-directed mode using a detected version of the output signal. To
use a training sequence when invoking the `equalize`

function, include the symbols of the training sequence as an input
vector.

As an exception, CMA equalizers do not use a training sequence. If an equalizer object is based on CMA, you should not include a training sequence as an input vector.

The following code illustrates how to use
`equalize`

with a training sequence. The training
sequence in this case is just the beginning of the transmitted
message.

% Set up parameters and signals. M = 4; % Alphabet size for modulation msg = randi([0 M-1],1500,1); % Random message hMod = comm.QPSKModulator('PhaseOffset',0); modmsg = step(hMod,msg); % Modulate using QPSK. trainlen = 500; % Length of training sequence chan = [.986; .845; .237; .123+.31i]; % Channel coefficients filtmsg = filter(chan,1,modmsg); % Introduce channel distortion. % Equalize the received signal. eq1 = lineareq(8, lms(0.01)); % Create an equalizer object. eq1.SigConst = step(hMod,(0:M-1)')'; % Set signal constellation. [symbolest,yd] = equalize(eq1,filtmsg,modmsg(1:trainlen)); % Equalize. % Plot signals. h = scatterplot(filtmsg,1,trainlen,'bx'); hold on; scatterplot(symbolest,1,trainlen,'g.',h); scatterplot(eq1.SigConst,1,0,'k*',h); legend('Filtered signal','Equalized signal',... 'Ideal signal constellation'); hold off; % Compute error rates with and without equalization. hDemod = comm.QPSKDemodulator('PhaseOffset',0); demodmsg_noeq = step(hDemod,filtmsg); % Demodulate unequalized signal. demodmsg = step(hDemod,yd); % Demodulate detected signal from equalizer. hErrorCalc = comm.ErrorRate; % ErrorRate calculator ser_noEq = step(hErrorCalc, ... msg(trainlen+1:end), demodmsg_noeq(trainlen+1:end)); reset(hErrorCalc) ser_Eq = step(hErrorCalc, msg(trainlen+1:end),demodmsg(trainlen+1:end)); disp('Symbol error rates with and without equalizer:') disp([ser_Eq(1) ser_noEq(1)])

The example goes on to determine how many errors occur in trying to recover the modulated message with and without the equalizer. The symbol error rates, below, show that the equalizer improves the performance significantly.

Symbol error rates with and without equalizer: 0 0.3410

The example also creates a scatter plot that shows the signal before and after equalization, as well as the signal constellation for QPSK modulation. Notice on the plot that the points of the equalized signal are clustered more closely around the points of the signal constellation.

**Equalizing Using a Training Sequence in Simulink. **To train a non-CMA equalizer block at the beginning of each frame
throughout the simulation, follow these steps:

Clear the

**Mode input port**check box.Provide the training sequence at the input port labeled

`Desired`

. Valid training symbols are those listed in the**Signal constellation**vector. The block operates in training mode at the beginning of each frame and switches to decision-directed mode when it runs out of training symbols.

Typically, the symbol periods of the `Input`

and
`Desired`

inputs match; that is, the sample time of the
`Desired`

signal is k times the sample time of the
`Input`

signal, where k is the **Number of
samples per symbol** parameter in the equalizer block. If your
training sequence is constant throughout the simulation, the Simulink
Constant block is a convenient way to specify the sequence without having to
specify a sample time explicitly.

To train a non-CMA equalizer block only on selected frames during the simulation, see Equalize in Decision-Directed Mode Using MATLAB.

**Equalize in Decision-Directed Mode Using MATLAB. **Decision-directed mode means the equalizer uses a detected version of its
output signal when adapting the weights. Adaptive equalizers typically start
with a training sequence (as mentioned in Equalize Using a Training Sequence in MATLAB)
and switch to decision-directed mode after exhausting all symbols in the
training sequence. CMA equalizers are an exception, using neither training
mode nor decision-directed mode.

For non-CMA equalizers, the `equalize`

function
operates in decision-directed mode when one of these conditions is
true:

The syntax does not include a training sequence.

The equalizer has exhausted all symbols in the training sequence and still has more input symbols to process.

The example in Controlling the Use of Training or Decision-Directed Mode
uses training mode when processing the first `trainlen`

symbols of the input signal, and decision-directed mode thereafter. The
example below discusses another scenario.

If you invoke `equalize`

multiple times with
the same equalizer object to equalize a series of signal vectors,
you might use a training sequence the first time you call the
function and omit the training sequence in subsequent calls. Each
iteration of the `equalize`

function after the
first one operates completely in decision-directed mode. However,
because the `ResetBeforeFiltering`

property of the
equalizer object is set to `0`

, the
`equalize`

function uses the existing state
information in the equalizer object when starting each iteration's
equalization operation. As a result, the training affects all
equalization operations, not just the first.

The code below illustrates this approach. Notice that the first
call to `equalize`

uses a training sequence as an
input argument, and the second call to `equalize`

omits a training sequence.

M = 4; % Alphabet size for modulation msg = randi([0 M-1],1500,1); % Random message hMod = comm.QPSKModulator('PhaseOffset',0); modmsg = step(hMod,msg); % Modulate using QPSK. trainlen = 500; % Length of training sequence chan = [.986; .845; .237; .123+.31i]; % Channel coefficients filtmsg = filter(chan,1,modmsg); % Introduce channel distortion. % Set up equalizer. eqlms = lineareq(8, lms(0.01)); % Create an equalizer object. eqlms.SigConst = step(hMod,(0:M-1)')'; % Set signal constellation. % Maintain continuity between calls to equalize. eqlms.ResetBeforeFiltering = 0; % Equalize the received signal, in pieces. % 1. Process the training sequence. s1 = equalize(eqlms,filtmsg(1:trainlen),modmsg(1:trainlen)); % 2. Process some of the data in decision-directed mode. s2 = equalize(eqlms,filtmsg(trainlen+1:800)); % 3. Process the rest of the data in decision-directed mode. s3 = equalize(eqlms,filtmsg(801:end)); s = [s1; s2; s3]; % Full output of equalizer

**Equalize in Decision-Directed Mode Using Simulink. **Decision-directed mode means that the equalizer uses a detected version of
its output signal when adapting the weights. Adaptive equalizers typically
start with a training sequence (as mentioned in Equalizing Using a Training Sequence in Simulink) and switch to
decision-directed mode after exhausting all symbols in the training
sequence. CMA equalizers are an exception, using neither training mode nor
decision-directed mode. The non-CMA equalizer blocks in this library operate
in decision-directed mode when one of these conditions is true:

The equalizer started processing the current input frame in training mode, exhausted all symbols in the training sequence frame, and still has more input symbols to process.

The

**Mode input port**check box is selected and the`Mode`

input signal is`0`

.

You can configure a non-CMA equalizer block so that it adapts in
training mode for the beginning or the entirety of
*selected* frames. To achieve this level of
control over the equalizer's mode, follow these steps:

Enable the

`Mode`

input port by checking the**Mode input port**check box.Send a binary-valued scalar signal to the

`Mode`

input port. The`Mode`

input enables you to toggle back and forth between training mode and decision-directed mode. The significance of this signal is as follows:When the

`Mode`

input is`0`

, the equalizer operates in decision-directed mode on the entire frame and ignores the`Desired`

input.When the

`Mode`

input is`1`

, the equalizer operates in training mode at the beginning of the frame until it exhausts the symbols in the`Desired`

input, and operates in decision-directed mode afterwards. If the`Mode`

input is`1`

and the`Desired`

input has as many symbols as the`Input`

signal has, then the equalizer operates in training mode on the entire frame.

**Delays from Equalization. **For proper equalization using adaptive algorithms other than CMA, you
should set the reference tap so that it exceeds the delay, in symbols,
between the transmitter's modulator output and the equalizer input. When
this condition is satisfied, the total delay between the modulator output
and the equalizer output is equal to

`(RefTap-1)/nSampPerSym`

symbols. Because the channel delay is typically unknown, a common practice is to set the reference tap to the center tap in a linear equalizer, or the center tap of the forward filter in a decision-feedback equalizer.

For CMA equalizers, the expression above does not apply because a CMA
equalizer has no reference tap. If you need to know the delay, you can find
it empirically after the equalizer weights have converged. Use the `xcorr`

function to examine
cross-correlations of the modulator output and the equalizer output.

Here are some typical ways to take a delay of D into account by padding or truncating data:

Pad your original data with D extra symbols at the end. Before comparing the original data with the received data, omit the first D symbols of the received data. In this approach, all the original data (not including the padding) is accounted for in the received data.

Before comparing the original data with the received data, omit the last D symbols of the original data and the first D symbols of the received data. In this approach, some of the original symbols are not accounted for in the received data.

The example below illustrates the latter approach. For an example that illustrates both approaches in the context of interleavers, see Delays of Convolutional Interleavers.

M = 2; % Use BPSK modulation for this example. msg = randi([0 M-1],1000,1); % Random data hMod = comm.BPSKModulator('PhaseOffset',0); modmsg = step(hMod,msg); % Modulate trainlen = 100; % Length of training sequence trainsig = modmsg(1:trainlen); % Training sequence % Define an equalizer and equalize the received signal. eqlin = lineareq(3,normlms(.0005,.0001),pskmod(0:M-1,M)); eqlin.RefTap = 2; % Set reference tap of equalizer. [eqsig,detsym] = equalize(eqlin,modmsg,trainsig); % Equalize. hDemod = comm.BPSKDemodulator('PhaseOffset',0); detmsg = step(hDemod,detsym); % Demodulate the detected signal. % Compute bit error rate while compensating for delay introduced by RefTap % and ignoring training sequence. D = (eqlin.RefTap -1)/eqlin.nSampPerSym; hErrorCalc = comm.ErrorRate('ReceiveDelay',D); berVec = step(hErrorCalc, msg(trainlen+1:end), detmsg(trainlen+1:end)); ber = berVec(1) numerrs = berVec(2)

The output is below.

numerrs = 0 ber = 0

**Equalize Using a Loop. **If your data is partitioned into a series of vectors (that you process
within a loop, for example), you can invoke the
`equalize`

function multiple times, saving the
equalizer's internal state information for use in a subsequent invocation.
In particular, the final values of the `WeightInputs`

and
`Weights`

properties in one equalization operation
should be the initial values in the next equalization operation. This
section gives an example, followed by more general procedures for
equalizing within a loop.

The example below illustrates how to use `equalize`

within a loop, varying the equalizer between iterations. Because the
example is long, this discussion presents it in these steps:

If you want to equalize iteratively while potentially changing equalizers between iterations, see Changing the Equalizer Between Iterations for help generalizing from this example to other cases.

The beginning of the example defines parameters and creates three equalizer objects:

An RLS equalizer object.

An LMS equalizer object.

A variable,

`eq_current`

, that points to the equalizer object to use in the current iteration of the loop. Initially, this points to the RLS equalizer object. After the second iteration of the loop,`eq_current`

is redefined to point to the LMS equalizer object.

% Set up parameters. M = 16; % Alphabet size for modulation sigconst = step(comm.RectangularQAMModulator(M),(0:M-1)'); % Signal constellation for 16-QAM chan = [1 0.45 0.3+0.2i]; % Channel coefficients hMod = comm.RectangularQAMModulator(M); % QAMModulator System object % Set up equalizers. eqrls = lineareq(6, rls(0.99,0.1)); % Create an RLS equalizer object. eqrls.SigConst = sigconst'; % Set signal constellation. eqrls.ResetBeforeFiltering = 0; % Maintain continuity between iterations. eqlms = lineareq(6, lms(0.003)); % Create an LMS equalizer object. eqlms.SigConst = sigconst'; % Set signal constellation. eqlms.ResetBeforeFiltering = 0; % Maintain continuity between iterations. eq_current = eqrls; % Point to RLS for first iteration.

The next portion of the example is a loop that

Generates a signal to transmit and selects a portion to use as a training sequence in the first iteration of the loop

Introduces channel distortion

Equalizes the distorted signal using the chosen equalizer for this iteration, retaining the final state and weights for later use

Plots the distorted and equalized signals, for comparison

Switches to an LMS equalizer between the second and third iterations

% Main loop for jj = 1:4 msg = randi([0 M-1],500,1); % Random message modmsg = step(hMod,msg); % Modulate using 16-QAM. % Set up training sequence for first iteration. if jj == 1 ltr = 200; trainsig = modmsg(1:ltr); else % Use decision-directed mode after first iteration. ltr = 0; trainsig = []; end % Introduce channel distortion. filtmsg = filter(chan,1,modmsg); % Equalize the received signal. s = equalize(eq_current,filtmsg,trainsig); % Plot signals. h = scatterplot(filtmsg(ltr+1:end),1,0,'bx'); hold on; scatterplot(s(ltr+1:end),1,0,'g.',h); scatterplot(sigconst,1,0,'k*',h); legend('Received signal','Equalized signal','Signal constellation'); title(['Iteration #' num2str(jj) ' (' eq_current.AlgType ')']); hold off; % Switch from RLS to LMS after second iteration. if jj == 2 eqlms.WeightInputs = eq_current.WeightInputs; % Copy final inputs. eqlms.Weights = eq_current.Weights; % Copy final weights. eq_current = eqlms; % Make eq_current point to eqlms. end end

The example produces one scatter plot for each iteration, indicating the iteration number and the adaptive algorithm in the title. A sample plot is below. Your plot might look different because this example uses random numbers.

This section describes two procedures for equalizing within a loop. The first procedure uses the same equalizer in each iteration, and the second is useful if you want to change the equalizer between iterations.

The typical procedure for using `equalize`

within a loop is as follows:

Before the loop starts, create the equalizer object that you want to use in the first iteration of the loop.

Set the equalizer object's

`ResetBeforeFiltering`

property to`0`

to maintain continuity between successive invocations of`equalize`

.Inside the loop, invoke

`equalize`

using a syntax like one of these:They = equalize(eqz,x,trainsig); y = equalize(eqz,x);

`equalize`

function updates the state and weights of the equalizer at the end of the current iteration. In the next iteration, the function continues from where it finished in the previous iteration because`ResetBeforeFiltering`

is set to`0`

.

This procedure is similar to the one used in Example: Equalizing Multiple Times, Varying the Mode.
That example uses `equalize`

multiple times but
not within a loop.

In some applications, you might want to modify the adaptive algorithm between iterations. For example, you might use a CMA equalizer for the first iteration and an LMS or RLS equalizer in subsequent iterations. The procedure below gives one way to accomplish this, roughly following the example in Example: Adaptive Equalization Within a Loop:

Before the loop starts, create the different kinds of equalizer objects that you want to use during various iterations of the loop.

For example, create one CMA equalizer object,

`eqcma`

, and one LMS equalizer object,`eqlms`

.For each equalizer object, set the

`ResetBeforeFiltering`

property to`0`

to maintain continuity between successive invocations of`equalize`

.Create a variable

`eq_current`

that points to the equalizer object you want to use for the first iteration. Use`=`

to establish the connection so that the two objects get updated together:eq_current = eqcma; % Point to eqcma.

The purpose of

`eq_current`

is to represent the equalizer used in each iteration, where you can switch equalizers from one iteration to the next by using a command like`eq_current = eqlms`

. The example illustrates this approach near the end of its loop.Inside the loop, perform these steps:

Invoke

`equalize`

using a syntax like one of these:y = equalize(eq_current,x,trainsig); y = equalize(eq_current,x);

Copy the values of the

`WeightInputs`

and`Weights`

properties from`eq_current`

to the equalizer object that you want to use for the next iteration. Use dot notation. For example,eqlms.WeightInputs = eq_current.WeightInputs; eqlms.Weights = eq_current.Weights;

Redefine

`eq_current`

to point to the equalizer object that you want to use for the next iteration, using`=`

. Now`eq_current`

is set up for the next iteration, because it represents the new kind of equalizer but retains the old values for the state and weights.

The reason for creating multiple equalizer objects and then copying the state and weights, instead of simply changing the equalizer class or adaptive algorithm in a single equalizer object, is that the class and adaptive algorithm properties of an equalizer object are fixed.

In Communications System Toolbox™, the `mlseeq`

function and MLSE Equalizer block
use the Viterbi algorithm to equalize a linearly modulated signal through a
dispersive channel. Both the function and the block output the maximum
likelihood sequence estimate of the signal, using an estimate of the channel
modeled as a finite input response (FIR) filter.

Decoding a received signal uses these steps:

Applies the FIR filter, corresponding to the channel estimate, to the symbols in the input signal.

Uses the Viterbi algorithm to compute the traceback paths and the state metric, which are the numbers assigned to the symbols at each step of the Viterbi algorithm. The metrics are based on Euclidean distance.

Outputs the maximum likelihood sequence estimate of the signal, as a sequence of complex numbers corresponding to the constellation points of the modulated signal.

An MLSE equalizer yields the best possible performance, in theory, but is computationally intensive.

For background material about MLSE equalizers, see the works listed in Selected Bibliography for Equalizers.

When using the MLSE Equalizer block, you specify the channel estimate and the signal constellation that the modulator in your model uses. If applicable, you can also specify a preamble and/or postamble that you expect to accompany your data. For full details on options, see the reference page for the MLSE Equalizer block.

In its simplest form, the `mlseeq`

function equalizes a
vector of modulated data when you specify the estimated coefficients of the
channel (modeled as an FIR filter), the signal constellation for the modulation
type, and the traceback depth that you want the Viterbi algorithm to use. Larger
values for the traceback depth can improve the results from the equalizer but
increase the computation time.

An example of the basic syntax for `mlseeq`

is
below.

M = 4; hMod = comm.QPSKModulator; const = step(hMod,(0:M-1)'); % 4-PSK constellation msg = step(hMod,[1 2 2 0 3 1 3 3 2 1 0 2 3 0 1]'); % Modulated message chcoeffs = [.986; .845; .237; .12345+.31i]; % Channel coefficients filtmsg = filter(chcoeffs,1,msg); % Introduce channel distortion. tblen = 10; % Traceback depth for equalizer chanest = chcoeffs; % Assume the channel is known exactly. hMLSEE = comm.MLSEEqualizer('TracebackDepth',tblen,... 'Channel',chanest, 'Constellation',const); msgEq = step(hMLSEE,filtmsg); % Equalize.

The `mlseeq`

function has two operation modes:

Continuous operation mode enables you to process a series of vectors using repeated calls to

`mlseeq`

, where the function saves its internal state information from one call to the next. To learn more, see Equalizing in Continuous Operation Mode.Reset operation mode enables you to specify a preamble and postamble that accompany your data. To learn more, see Using a Preamble or Postamble.

If you are not processing a series of vectors and do not need to specify a preamble or postamble, the operation modes are nearly identical. However, they differ in that continuous operation mode incurs a delay, while reset operation mode does not. The example above could have used either mode, except that substituting continuous operation mode would have produced a delay in the equalized output. To learn more about the delay in continuous operation mode, see Delays in Continuous Operation Mode.

If your data is partitioned into a series of vectors (that you process within
a loop, for example), continuous operation mode is an appropriate way to use the
`mlseeq`

function. In continuous operation mode,
`mlseeq`

can save its internal state information for use
in a subsequent invocation and can initialize using previously stored state
information. To choose continuous operation mode, use `'cont'`

as an input argument when invoking `mlseeq`

.

Continuous operation mode incurs a delay, as described in Delays in Continuous Operation Mode. Also, continuous operation mode cannot accommodate a preamble or postamble.

**Procedure for Continuous Operation Mode. **The typical procedure for using continuous mode within a loop is as follows:

Before the loop starts, create three empty matrix variables (for example,

`sm`

,`ts`

,`ti`

) that eventually store the state metrics, traceback states, and traceback inputs for the equalizer.Inside the loop, invoke

`mlseeq`

using a syntax likeUsing[y,sm,ts,ti] = mlseeq(x,chcoeffs,const,tblen,'cont',nsamp,sm,ts,ti);

`sm`

,`ts`

, and`ti`

as input arguments causes`mlseeq`

to continue from where it finished in the previous iteration. Using`sm`

,`ts`

, and`ti`

as output arguments causes`mlseeq`

to update the state information at the end of the current iteration. In the first iteration,`sm`

,`ts`

, and`ti`

start as empty matrices, so the first invocation of the`mlseeq`

function initializes the metrics of all states to 0.

**Delays in Continuous Operation Mode. **Continuous operation mode with a traceback depth of
`tblen`

incurs an output delay of
`tblen`

symbols. This means that the first
`tblen`

output symbols are unrelated to the input
signal, while the last `tblen`

input symbols are unrelated
to the output signal. For example, the command below uses a traceback depth
of `3`

, and the first 3 output symbols are unrelated to the
input signal of `ones(1,10)`

.

y = step(comm.MLSEEqualizer('Channel',1, 'Constellation',[-7:2:7], ... 'TracebackDepth',3,'TerminationMethod', 'Continuous'), ... complex(ones(10,1))) y = -7 -7 -7 1 1 1 1 1 1 1

Keeping track of delays from different portions of a communication system is important, especially if you compare signals to compute error rates. The example in Example: Continuous Operation Mode illustrates how to take the delay into account when computing an error rate.

**Example: Continuous Operation Mode. **The example below illustrates the procedure for using continuous operation
mode within a loop. Because the example is long, this discussion presents it
in multiple steps:

The beginning of the example defines parameters, initializes the state
variables `sm`

, `ts`

, and
`ti`

, and initializes variables that accumulate
results from each iteration of the loop.

n = 200; % Number of symbols in each iteration numiter = 25; % Number of iterations M = 4; % Use 4-PSK modulation. hMod = comm .QPSKModulator('PhaseOffset',0); const = step(hMod,(0:M-1)'); % PSK constellation chcoeffs = [1 ; 0.25]; % Channel coefficients chanest = chcoeffs; % Channel estimate tblen = 10; % Traceback depth for equalizer sm = []; ts = []; ti = []; % Initialize equalizer data. % Initialize cumulative results. fullmodmsg = []; fullfiltmsg = []; fullrx = []; hMLSEE = comm.MLSEEqualizer('TracebackDepth',tblen, 'Channel', chanest, ... 'Constellation',const, 'TerminationMethod', 'Continuous');

The middle portion of the example is a loop that generates random
data, modulates it using baseband PSK modulation, and filters it.
Finally, `mlseeq`

equalizes the filtered data. The
loop also updates the variables that accumulate results from each
iteration of the loop.

for jj = 1:numiter msg = randi([0 M-1],n,1); % Random signal vector modmsg = step(hMod,msg); % PSK-modulated signal filtmsg = filter(chcoeffs,1,modmsg); % Filtered signal rx = step(hMLSEE,filtmsg); % Equalize % Update vectors with cumulative results. fullmodmsg = [fullmodmsg; modmsg]; fullfiltmsg = [fullfiltmsg; filtmsg]; fullrx = [fullrx; rx]; end

The last portion of the example computes the symbol error rate
from all iterations of the loop. The `symerr`

function compares selected portions of the received and transmitted
signals, not the entire signals. Because continuous operation mode
incurs a delay whose length in samples is the traceback depth
(`tblen`

) of the equalizer, it is necessary to
exclude the first `tblen`

samples from the received
signal and the last `tblen`

samples from the
transmitted signal. Excluding samples that represent the delay of
the equalizer ensures that the symbol error rate calculation
compares samples from the received and transmitted signals that are
meaningful and that truly correspond to each other.

The example also plots the signal before and after equalization in a scatter plot. The points in the equalized signal coincide with the points of the ideal signal constellation for 4-PSK.

% Compute total number of symbol errors. Take the delay into account. hErrorCalc = comm.ErrorRate('ReceiveDelay',10); err = step(hErrorCalc, fullmodmsg, fullrx); numsymerrs = err(1) % Plot signal before and after equalization. h = scatterplot(fullfiltmsg); hold on; scatterplot(fullrx,1,0,'r*',h); legend('Filtered signal before equalization','Equalized signal',... 'Location','NorthOutside'); hold off;

The output and plot follow.

numsymerrs = 0

Some systems include a sequence of known symbols at the beginning or end of a
set of data. The known sequence at the beginning or end is called a
*preamble* or *postamble*,
respectively. The `mlseeq`

function can accommodate a
preamble and postamble that are already incorporated into its input signal. When
you invoke the function, you specify the preamble and postamble as integer
vectors that represent the sequence of known symbols by indexing into the signal
constellation vector. For example, a preamble vector of ```
[1 4
4]
```

and a 4-PSK signal constellation of ```
[1 j -1
-j]
```

indicate that the modulated signal begins with ```
[1 -j
-j]
```

.

If your system uses a preamble without a postamble, use a postamble vector of
`[]`

when invoking `mlseeq`

. Similarly,
if your system uses a postamble without a preamble, use a preamble vector of
`[]`

.

**Use a Preamble in MATLAB**

The example below illustrates how to accommodate a preamble when using
`mlseeq`

. The same preamble symbols appear at the
beginning of the message vector and in the syntax for
`mlseeq`

. If you want to use a postamble, you can
append it to the message vector and also include it as the last input
argument for `mlseeq`

. In this example, however, the
postamble input in the `mlseeq`

syntax is an empty
vector because the system uses no postamble.

M = 4; hMod = comm.QPSKModulator;% Use 4-PSK modulation. const = step(hMod,(0:M-1)'); % PSK constellation tblen = 16; % Traceback depth for equalizer preamble = [3; 1]; % Expected preamble, as integers msgIdx = randi([0 M-1],98,1); % Random symbols msgIdx = [preamble; msgIdx]; % Include preamble at the beginning. msg = step(hMod,msgIdx); % Modulated message chcoeffs = [.623; .489+.234i; .398i; .21]; % Channel coefficients chanest = chcoeffs; % Channel estimate hMLSEE = comm.MLSEEqualizer('TracebackDepth',tblen,... 'Channel',chanest, 'Constellation',const, ... 'PreambleSource', 'Property', 'Preamble', preamble); filtmsg = filter(chcoeffs,1,msg); % Introduce channel distortion. d = step(hMLSEE,filtmsg); % Symbol error rate hErrorCalc = comm.ErrorRate; serVec = step(hErrorCalc, msg,d); ser = serVec(1) nsymerrs = serVec(2)

The output is below.

nsymerrs = 0 ser = 0

The MLSE Equalizer block uses the Viterbi algorithm to equalize a linearly modulated signal through a dispersive channel. The block outputs the maximum likelihood sequence estimate (MLSE) of the signal, using your estimate of the channel modeled as a finite input response (FIR) filter.

The block decodes the received signal using these steps:

Applies the FIR filter corresponding to the channel estimate to the symbols in the input signal.

Uses the Viterbi algorithm to compute the traceback paths and the state metric, which are the numbers assigned to the symbols at each step of the Viterbi algorithm.

Outputs the maximum likelihood sequence estimate of the signal, as a sequence of complex numbers corresponding to the constellation points of the modulated signal.

An MLSE equalizer yields the best possible performance, in theory, but is computationally intensive.

When using the MLSE Equalizer block, you specify the channel estimate and the signal constellation that the modulator in your model uses. If applicable, you can also specify a preamble and/or postamble that you expect to accompany your data. For full details on options, see the reference page for the MLSE Equalizer block.

[1] Farhang-Boroujeny, B., *Adaptive
Filters: Theory and Applications*, Chichester, England,
John Wiley & Sons, 1998.

[2] Haykin, Simon, *Adaptive Filter
Theory*, Third Ed., Upper Saddle River, NJ, Prentice-Hall,
1996.

[3] Kurzweil, Jack, *An Introduction
to Digital Communications*, New York, John Wiley &
Sons, 2000.

[4] Proakis, John G., *Digital
Communications*, Fourth Ed., New York, McGraw-Hill, 2001.

[5] Steele, Raymond, Ed., *Mobile
Radio Communications*, Chichester, England, John Wiley
& Sons, 1996.

Was this topic helpful?