Документация

dfe = comm.DecisionFeedbackEqualizer создает уравнитель обратной связи принятия решения Системного объекта чтобы адаптивно выравнивать сигнал.

dfe = comm.DecisionFeedbackEqualizer(Name,Value) устанавливает свойства с помощью одной или нескольких пар "имя-значение". Для примера, comm.DecisionFeedbackEqualizer('Algorithm','RLS') конфигурирует объект эквалайзера для обновления весов отводов с помощью рекурсивного алгоритма наименьших квадратов (RLS). Заключайте каждое имя свойства в кавычки.

Свойства

Если не указано иное, свойства являются нетронутыми, что означает, что вы не можете изменить их значения после вызова объекта. Объекты блокируются, когда вы вызываете их, и release функция разблокирует их.

Если свойство настраивается, можно изменить его значение в любой момент.

Для получения дополнительной информации об изменении значений свойств смотрите Разработку системы в MATLAB Использование Системных объектов.

`Algorithm` - Адаптивный алгоритм
`'LMS'` (по умолчанию) | `'RLS'` | `'CMA'`

Адаптивный алгоритм, используемый для эквализации, задается как одно из следующих значений:

'LMS' - Обновите веса отводов эквалайзера с помощью алгоритма наименьшего среднего квадрата (LMS).
'RLS' - Обновите веса отводов эквалайзера с помощью Рекурсивного алгоритма наименьшего квадрата (RLS).
'CMA' - Обновите веса отводов эквалайзера с помощью алгоритма постоянного модуля (CMA).

Типы данных: char | string

`NumForwardTaps` - Количество отводов прямого эквалайзера
`5` (по умолчанию) | положительное целое число

Количество ответвлений прямого эквалайзера, заданное как положительное целое число. Количество отводов прямого эквалайзера должно быть больше или равным значению InputSamplesPerSymbol свойство.

Типы данных: double

`NumFeedbackTaps` - Количество ответвлений эквалайзера с обратной связью
`3` (по умолчанию) | положительное целое число

Количество ответвлений эквалайзера с обратной связью, заданное как положительное целое число.

Типы данных: double

`StepSize` - Размер шага
`0.01` (по умолчанию) | положительная скалярная величина

Совет

Чтобы определить максимально допустимый размер шага, используйте maxstep функция объекта.

Настраиваемый: Да

Зависимости

Чтобы включить это свойство, установите значение Algorithm равным 'LMS' или 'CMA'.

Типы данных: double

`ForgettingFactor` - Коэффициент забывания
`0.99` (по умолчанию) | скаляром в области значений (0, 1]

Настраиваемый: Да

Зависимости

Чтобы включить это свойство, установите значение Algorithm равным 'RLS'.

Типы данных: double

`InitialInverseCorrelationMatrix` - Исходная матрица обратной корреляции
`0.1` (по умолчанию) | скалярную матрицу |

Матрица начальной обратной корреляции, заданная как скаляр или N матрица _Taps-by _{N Taps}_{. N} Taps равно сумме значений свойств NumForwardTaps и NumFeedbackTaps. Если вы задаете InitialInverseCorrelationMatrix в качестве скаляра, a, эквалайзер устанавливает начальную матрицу обратной корреляции в a раза больше единичной матрицы: a (eye(N _Taps)).

Настраиваемый: Да

Зависимости

Чтобы включить это свойство, установите значение Algorithm равным 'RLS'.

Типы данных: double

`Constellation` - Сигнальное созвездие
`pskmod(0:3,4,pi/4)` (по умолчанию) | вектор

Сигнальное созвездие, заданное как вектор. Значением по умолчанию является созвездие QPSK, сгенерированное с использованием этого кода: pskmod(0:3,4,pi/4).

Настраиваемый: Да

Типы данных: double

`ReferenceTap` - Ссылочный кран
`3` (по умолчанию) | положительное целое число

Ссылочный контакт, заданный как положительное целое число, меньше или равное значению свойства NumForwardTaps. Эквалайзер использует положение ссылки отвода, чтобы отследить основную энергию канала.

Типы данных: double

`InputDelay` - Задержка входного сигнала
`0` (по умолчанию) | неотрицательное целое число

Задержка входного сигнала в выборках относительно времени сброса эквалайзера, заданная как неотрицательное целое число. Если входной сигнал является вектором длины, большей 1, то вход задержка относительно начала вектора входа. Если входной сигнал является скаляром, то входная задержка относится к первому вызову системного объекта и к первому вызову системного объекта после вызова release или reset функция объекта.

Типы данных: double

`InputSamplesPerSymbol` - Количество входных выборок на символ
`1` (по умолчанию) | положительное целое число

Количество входа отсчетов на символ, заданное в виде положительного целого числа. Установка этого свойства на любое число, больше единицы, эффективно создает фракционно разнесенный эквалайзер.

Типы данных: double

`TrainingFlagInputPort` - Включите вход управления обучением
`false` (по умолчанию) | `true`

Включите вход управления обучением, заданный как false или true. Установка значения свойства true включает вход флага обучения эквалайзера tf.

Настраиваемый: Да

Типы данных: logical

`AdaptAfterTraining` - Обновляйте веса касаний, когда нет обучения
`true` (по умолчанию) | `false`

Обновляйте веса касаний, когда нет обучения, задается как true или false. Если для этого свойства задано значение true, Системный объект использует режим, ориентированный на принятие решений, чтобы обновить веса отводов эквалайзера. Если для этого свойства задано значение false, Системный объект сохраняет веса отводов эквалайзера неизменными после обучения.

Настраиваемый: Да

Типы данных: logical

`AdaptWeightsSource` - Источник запроса на адаптацию весов отводов
`'Property'` (по умолчанию) | `'Input port'`

Источник запроса adapt tap weights, заданный как одно из следующих значений:

'Property' - Задайте это значение, чтобы использовать свойство AdaptWeights для управления, когда системный объект адаптирует веса прикосновений.
'Input port' - Задайте это значение, чтобы использовать aw вход для управления, когда системный объект адаптирует веса касаний.

Зависимости

Чтобы включить это свойство, установите значение Algorithm равным 'CMA'.

Типы данных: char | string

`AdaptWeights` - Адаптируйте веса касаний
`true` (по умолчанию) | `false`

Адаптируйте веса касаний, заданные как true или false. Если для этого свойства задано значение true, Системный объект обновляет веса отводов эквалайзера. Если для этого свойства задано значение false, Системный объект сохраняет веса отводов эквалайзера неизменными.

Настраиваемый: Да

Зависимости

Чтобы включить это свойство, установите AdaptWeightsSource на 'Property' и установите AdaptAfterTraining на true.

Типы данных: logical

`InitialWeightsSource` - Источник для начальных весов отводов
`'Auto'` (по умолчанию) | `'Property'`

Источник для начальных весов отвода, заданный как одно из следующих значений:

'Auto' - Инициализируйте веса прикосновений к специфичным для алгоритма значениям по умолчанию, как описано в свойстве InitialWeights.
'Property' - Инициализируйте веса отводов с помощью значения свойства InitialWeights.

Типы данных: char | string

`InitialWeights` - Начальные веса
`0` или `[0;0;1;0;0]` (по умолчанию) | скалярный вектор |

Начальные веса, используемые адаптивным алгоритмом, заданные в виде скаляра или вектора. Значение по умолчанию является 0 когда для свойства Algorithm задано значение 'LMS' или 'RLS'. Значение по умолчанию является [0;0;1;0;0] когда для свойства Algorithm задано значение 'CMA'.

Если вы задаете InitialWeights в качестве скаляра эквалайзер использует скалярное расширение, чтобы создать вектор длины N _Taps со всеми значениями, установленными на InitialWeights. N _Taps равно сумме значений свойств NumForwardTaps и NumFeedbackTaps. Если вы задаете InitialWeights как вектор, длина вектора должна быть N _Taps.

Настраиваемый: Да

Типы данных: double

`WeightUpdatePeriod` - Коснитесь периода обновления веса
`1` (по умолчанию) | положительное целое число

Коснитесь периода обновления веса в символах, заданных как положительное целое число. Эквалайзер обновляет веса отводов после обработки этого количества символов.

Типы данных: double

Использование

Синтаксис

y = dfe(x,tsym)

y = dfe(x,tsym,tf)

y = dfe(x)

y = dfe(x,aw)

[y,err] = dfe(___)

[y,err,weights] = dfe(___)

Описание

y = dfe(x,tsym) выравнивает входной сигнал x при помощи обучающих символов tsym. Выходные выходы - уравненные символы. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'LMS' или 'RLS'.

y = dfe(x,tsym,tf) также задает флаг обучения tf. Обучение Системного объекта начинает, когда tf изменения от false на true (на переднем ребре). Системный объект обучается до тех пор, пока все символы не будут tsym обрабатываются. Область входа tsym игнорируется, когда tf является false. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'LMS' или 'RLS' и свойство TrainingFlagInportPort в true.

y = dfe(x) выравнивает входной сигнал x. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'CMA'.

y = dfe(x,aw) также задает флаг адаптирует веса aw. Системный объект адаптирует веса ответвлений эквалайзера при aw является true. Если aw является falseСистемный объект сохраняет веса неизменными. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'CMA' и свойство AdaptWeightsSource к 'Input port'.

[y,err] = dfe(___) также возвращает сигнал ошибки err использование входных параметров из любого из предыдущих синтаксисов.

[y,err,weights] = dfe(___) также возвращается weights, веса касания из последнего обновления веса касания, используя входные параметры от любого из предыдущих синтаксисов.

Входные параметры

`x` - Входной сигнал
Вектор-столбец

Входной сигнал, заданный как вектор-столбец. Длина вектора входного сигнала должна быть равна целому числу, кратному значению свойства InputSamplesPerSymbol. Для получения дополнительной информации см. Раздел «Промежутки между символами».

Типы данных: double
Поддержка комплексного числа: Да

`tsym` - Обучающие символы
Вектор-столбец

Обучающие символы, заданные как вектору-столбцу длины, меньшей или равной длине входа x. Область входа tsym игнорируется, когда tf является false.

Зависимости

Чтобы включить этот аргумент, задайте значение свойства Algorithm 'LMS' или 'RLS'.

Типы данных: double

`tf` - Флаг обучения
`true` | `false`

Флаг обучения, заданный как true или false. Обучение Системного объекта начинает, когда tf изменения от false на true (на переднем ребре). Системный объект обучается до тех пор, пока все символы не будут tsym обрабатываются. Область входа tsym игнорируется, когда tf является false.

Зависимости

Чтобы включить этот аргумент, задайте значение свойства Algorithm 'LMS' или 'RLS' и свойство TrainingFlagInportPort в true.

Типы данных: logical

`aw` - Флаг адаптации весов
`true` | `false`

Адаптируйте флаг весов, заданный как true или false. Если aw является trueСистемный объект адаптирует веса. Если aw является falseСистемный объект сохраняет веса неизменными.

Зависимости

Чтобы включить этот аргумент, задайте значение свойства Algorithm 'CMA' и свойство AdaptWeightsSource к 'Input port'.

Типы данных: logical

Выходные аргументы

`y` - Выравниваемые символы
Вектор-столбец

Уравненные символы, возвращенные как вектор-столбец, имеющий ту же длину, что и входной сигнал x.

`err` - Сигнал ошибки
Вектор-столбец

Сигнал ошибки, возвращенный как вектор-столбец, который имеет ту же длину, что и входной сигнал x.

`weights` - Контрольные веса
Вектор-столбец

Коснитесь веса, возвращенные как вектор-столбец, который имеет N элементов _Tops. _{N Taps} равно сумме значений свойств NumForwardTaps и NumFeedbackTaps. weights содержит веса касаний из последнего обновления весов касаний.

Функции объекта

Чтобы использовать функцию объекта, задайте системный объект в качестве первого входного параметра. Например, чтобы освободить системные ресурсы системного объекта с именем obj, используйте следующий синтаксис:

release(obj)

Характерно для `comm.DecisionFeedbackEqualizer`

`isLocked`	Определите, используется ли системный объект
`clone`	Создайте повторяющийся системный объект
`info`	Характеристическая информация об объекте эквалайзера
`maxstep`	Максимальный размер шага для сходимости эквалайзера LMS
`mmseweights`	Веса отводов линейного эквалайзера MMSE

Общий для всех системных объектов

`step`	Запуск алгоритма системного объекта
`release`	Отпустите ресурсы и допустите изменения в значениях свойств системного объекта и входных характеристиках
`reset`	Сброс внутренних состояний Системного объекта

Примеры

свернуть все

Обратная связь принятия решения выравнивает BPSK-модулированный сигнал

Создайте модулятор BPSK и систему object™ эквалайзера, задающие эквалайзер LMS с обратной связью принятия решения, имеющий восемь прямых отводов, пять отводов с обратной связью и размер шага 0,03.

bpsk = comm.BPSKModulator;
eqdfe_lms = comm.DecisionFeedbackEqualizer('Algorithm','LMS', ...
    'NumForwardTaps',8,'NumFeedbackTaps',5,'StepSize',0.03);

Измените ссылочный индекс отвода эквалайзера.

eqdfe_lms.ReferenceTap = 4;

Создайте набор тестовых данных. Получите данные путем свертки сигнала.

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

Использование maxstep для поиска максимально допустимого размера шага.

mxStep = maxstep(eqdfe_lms,rxsig)

mxStep = 0.1028

Выравнивание принимаемого сигнала. Используйте первые 200 символов в качестве обучающей последовательности.

y = eqdfe_lms(rxsig,x(1:200));

Обратная связь принятия решения выравнивает модулированный QPSK сигнал

Примените эквализацию обратной связи принятия решения с помощью алгоритма наименьших средних квадратов (LMS), чтобы восстановить символы QPSK, прошедшие через задержанный многолучевой канал AWGN.

Инициализируйте переменные симуляции.

M = 4; % QPSK
numSymbols = 10000;
numTrainingSymbols = 1000;
chtaps = [1 0.5*exp(1i*pi/6) 0.1*exp(-1i*pi/8)];

Сгенерируйте модулированные QPSK символы. Примените к символам фильтр многолучевого распространения и искажения AWGN.

data = randi([0 M-1], numSymbols, 1);
tx = pskmod(data, M, pi/4);
rx = awgn(filter(chtaps,1,tx),25,'measured');

Создайте Системный объект эквалайзера обратной связи принятия решения и отобразите строение по умолчанию. Отрегулируйте ссылочное касание так 1. Проверьте максимально допустимый размер шага. Выравнивание нарушенных символов.

eq = comm.DecisionFeedbackEqualizer

eq = 
  comm.DecisionFeedbackEqualizer with properties:

                Algorithm: 'LMS'
           NumForwardTaps: 5
          NumFeedbackTaps: 3
                 StepSize: 0.0100
            Constellation: [1x4 double]
             ReferenceTap: 3
               InputDelay: 0
    InputSamplesPerSymbol: 1
    TrainingFlagInputPort: false
       AdaptAfterTraining: true
     InitialWeightsSource: 'Auto'
       WeightUpdatePeriod: 1

eq.ReferenceTap = 1;

mxStep = maxstep(eq,rx)

mxStep = 0.2141

[y,err,weights] = eq(rx,tx(1:numTrainingSymbols));

Постройте график созвездия нарушенных и уравненных символов.

constell = comm.ConstellationDiagram('NumInputPorts',2);
constell(rx,y)

Figure Constellation Diagram contains an axes and other objects of type uiflowcontainer, uimenu, uitoolbar. The axes contains 4 objects of type line. These objects represent Channel 1, Channel 2.

Постройте график сигнала ошибки эквалайзера и вычислите величину вектора ошибок уравненных символов.

plot(abs(err))
grid on; xlabel('Symbols'); ylabel('|e|')

Figure contains an axes. The axes contains an object of type line.

errevm = comm.EVM;
evm = errevm(tx,y)

evm = 10.1621

Постройте график весов отводов эквалайзера.

subplot(3,1,1); stem(real(weights)); ylabel('real(weights)'); xlabel('Tap'); grid on; axis([1 8 -0.5 1])
line([eq.NumForwardTaps+0.5 eq.NumForwardTaps+0.5], [-0.5 1], 'Color', 'r', 'LineWidth', 1)
title('Equalizer Tap Weights')
subplot(3,1,2); stem(imag(weights)); ylabel('imag(weights)'); xlabel('Tap'); grid on; axis([1 8 -0.5 1])
line([eq.NumForwardTaps+0.5 eq.NumForwardTaps+0.5], [-0.5 1], 'Color', 'r', 'LineWidth', 1)
subplot(3,1,3); stem(abs(weights)); ylabel('abs(weights)'); xlabel('Tap'); grid on; axis([1 8 -0.5 1])
line([eq.NumForwardTaps+0.5 eq.NumForwardTaps+0.5], [-0.5 1], 'Color', 'r', 'LineWidth', 1)

Figure contains 3 axes. Axes 1 with title Equalizer Tap Weights contains 2 objects of type stem, line. Axes 2 contains 2 objects of type stem, line. Axes 3 contains 2 objects of type stem, line.

Обратная связь с решением выравнивает систему, используя различные схемы обучения

Продемонстрировать эквализацию обратной связи принятия решения с помощью алгоритма наименьших средних квадратов (LMS), чтобы восстановить символы QPSK, прошедшие через канал AWGN. Примените различные схемы обучения эквалайзера и отобразите величину ошибки символа.

Setup системы

Симулируйте систему с QPSK-модуляцией, удовлетворяющую AWGN. Передайте пакеты, состоящие из 200 обучающих символов и 1800 случайных символов данных. Сконфигурируйте эквалайзер LMS с обратной связью для принятия решений, чтобы восстановить пакетные данные.

M = 4;
numTrainSymbols = 200;
numDataSymbols = 1800;
SNR = 20;
trainingSymbols = pskmod(randi([0 M-1],numTrainSymbols,1),M,pi/4);
numPkts = 10;
dfeq = comm.DecisionFeedbackEqualizer('Algorithm','LMS', ...
    'NumForwardTaps',5,'NumFeedbackTaps',4,'ReferenceTap',3,'StepSize',0.01);

Обучите эквалайзер в начале каждого пакета с сбросом

Обработайте каждый пакет с помощью предварительно настроенных обучающих символов. Сбросьте эквалайзер после обработки каждого пакета. Сброс эквалайзера после каждого пакета заставляет эквалайзер обучать отводы без априорных знаний. Сигнал ошибки эквалайзера, графиков для первого, второго и последнего пакета, показывает более высокие символьные ошибки в начале каждого пакета.

jj = 1;
figure
for ii = 1:numPkts
    b = randi([0 M-1],numDataSymbols,1);
    dataSym = pskmod(b,M,pi/4);
    packet = [trainingSymbols;dataSym];
    rx = awgn(packet,SNR);
    [~,err] = dfeq(rx,trainingSymbols);
    reset(dfeq)
    if (ii ==1 || ii == 2 ||ii == numPkts)
        subplot(3,1,jj)
        plot(abs(err))
        ylim([0 1])
        title(['Packet # ',num2str(ii)])
        xlabel('Symbols');
        ylabel('Error Magnitude');
        grid on;
        jj = jj+1;
    end
end

Figure contains 3 axes. Axes 1 with title Packet # 1 contains an object of type line. Axes 2 with title Packet # 2 contains an object of type line. Axes 3 with title Packet # 10 contains an object of type line.

Обучите эквалайзер в начале каждого пакета без сброса

Обработайте каждый пакет с помощью предварительно настроенных обучающих символов. Не сбрасывайте эквалайзер после обработки каждого пакета. Не сбрасывая после каждого пакета, эквалайзер сохраняет веса отводов от обучающих предыдущих пакетов. Сигнал ошибки эквалайзера, графиков для первого, второго и последнего пакета, показывает, что после начального обучения на первом пакете последующие пакеты имеют меньше символьных ошибок в начале каждого пакета.

release(dfeq)
jj = 1;
figure
for ii = 1:numPkts
    b = randi([0 M-1],numDataSymbols,1);
    dataSym = pskmod(b,M,pi/4);
    packet = [trainingSymbols;dataSym];
    channel = 1;
    rx = awgn(packet*channel,SNR);
    [~,err] = dfeq(rx,trainingSymbols);
    if (ii ==1 || ii == 2 ||ii == numPkts)
        subplot(3,1,jj)
        plot(abs(err))
        ylim([0 1])
        title(['Packet # ',num2str(ii)])
        xlabel('Symbols');
        ylabel('Error Magnitude');
        grid on;
        jj = jj+1;
    end
end

Периодическое обучение эквалайзера

Системы с сигналами, подверженными изменяющимся во времени каналам, требуют периодического обучения эквалайзера для поддержания блокировки изменений канала. Задайте систему, которая имеет 200 символов обучения на каждые 1800 символов данных. Между обучением эквалайзер не обновляет веса касаний. Эквалайзер обрабатывает 200 символов на пакет.

Rs = 1e6;
fd = 20;
spp = 200; % Symbols per packet
b = randi([0 M-1],numDataSymbols,1);
dataSym = pskmod(b,M,pi/4);
packet = [trainingSymbols; dataSym];
stream = repmat(packet,10,1);
tx = (0:length(stream)-1)'/Rs;
channel = exp(1i*2*pi*fd*tx);
rx = awgn(stream.*channel,SNR);

Установите AdaptAfterTraining свойство к false для остановки обновления веса отвода эквалайзера после фазы обучения.

release(dfeq)
dfeq.AdaptAfterTraining = false

dfeq = 
  comm.DecisionFeedbackEqualizer with properties:

                Algorithm: 'LMS'
           NumForwardTaps: 5
          NumFeedbackTaps: 4
                 StepSize: 0.0100
            Constellation: [1x4 double]
             ReferenceTap: 3
               InputDelay: 0
    InputSamplesPerSymbol: 1
    TrainingFlagInputPort: false
       AdaptAfterTraining: false
     InitialWeightsSource: 'Auto'
       WeightUpdatePeriod: 1

Выравнивание нарушенных данных. Постройте график угловой ошибки из канала, сигнала ошибки эквалайзера и сигнального созвездия. Когда канал изменяется, выход эквалайзера не удаляет эффекты канала. Кроме того, выход созвездие вращается вне синхронизации, что приводит к битовым ошибкам.

[y,err] = dfeq(rx,trainingSymbols);

figure
subplot(2,1,1)
plot(tx, unwrap(angle(channel)))
xlabel('Time (sec)')
ylabel('Channel Angle (rad)')
title('Angular Error Over Time')
subplot(2,1,2)
plot(abs(err))
xlabel('Symbols')
ylabel('Error Magnitude')
grid on
title('Time-Varying Channel Without Retraining')

Figure contains 2 axes. Axes 1 with title Angular Error Over Time contains an object of type line. Axes 2 with title Time-Varying Channel Without Retraining contains an object of type line.

scatterplot(y)

Figure Scatter Plot contains an axes. The axes with title Scatter plot contains an object of type line. This object represents Channel 1.

Установите TrainingInputPort свойство к true чтобы сконфигурировать эквалайзер, чтобы переобучить отводы при сигнализации trainFlag вход. Эквалайзер тренируется только тогда, когда trainFlag является true. После каждого 2000 символов эквалайзер переобучает отводы и сохраняет блокировку изменений канала. Постройте график угловой ошибки из канала, сигнала ошибки эквалайзера и сигнального созвездия. Когда канал изменяется, выход эквалайзера удаляет эффекты канала. Кроме того, выходное созвездие не вращается вне синхронизации, и битовые ошибки уменьшаются.

release(dfeq)
dfeq.TrainingFlagInputPort = true;
symbolCnt = 0;
numPackets = length(rx)/spp;
trainFlag = true;
trainingPeriod = 2000;
eVec = zeros(size(rx));
yVec = zeros(size(rx));
for p=1:numPackets
    [yVec((p-1)*spp+1:p*spp,1),eVec((p-1)*spp+1:p*spp,1)] = ...
        dfeq(rx((p-1)*spp+1:p*spp,1),trainingSymbols,trainFlag);
    symbolCnt = symbolCnt + spp;
    if symbolCnt >= trainingPeriod
        trainFlag = true;
        symbolCnt = 0;
    else
        trainFlag = false;
    end
end
figure
subplot(2,1,1)
plot(tx, unwrap(angle(channel)))
xlabel('t (sec)')
ylabel('Channel Angle (rad)')
title('Angular Error Over Time')
subplot(2,1,2)
plot(abs(eVec))
xlabel('Symbols')
ylabel('Error Magnitude')
grid on
title('Time-Varying Channel With Retraining')

Figure contains 2 axes. Axes 1 with title Angular Error Over Time contains an object of type line. Axes 2 with title Time-Varying Channel With Retraining contains an object of type line.

scatterplot(yVec)

Figure Scatter Plot contains an axes. The axes with title Scatter plot contains an object of type line. This object represents Channel 1.

Обратная связь по решению выравнивает задержанный сигнал

Симулируйте систему с задержкой между переданными символами и принятыми выборками. Типичные системы имеют фильтры передатчика и приемника, которые приводят к задержке. Эта задержка должна быть учтена для синхронизации системы. В этом примере системная задержка вводится без фильтров передачи и приема. Эквализация обратной связи принятия решения, используя алгоритм наименьших средних квадратов (LMS), восстанавливает символы QPSK.

Инициализируйте переменные симуляции.

M = 4; % QPSK
numSymbols = 10000;
numTrainingSymbols = 1000;
mpChan = [1 0.5*exp(1i*pi/6) 0.1*exp(-1i*pi/8)];
systemDelay = dsp.Delay(20);
snr = 24;

Сгенерируйте модулированные QPSK символы. Примените многолучевую фильтрацию канала, системную задержку и AWGN к переданным символам.

data = randi([0 M-1],numSymbols,1);
tx = pskmod(data,M,pi/4); % OQPSK
delayedSym = systemDelay(filter(mpChan,1,tx));
rx = awgn(delayedSym,snr,'measured');

Создайте объекты equalizer и EVM System. Системный объект задает эквалайзер обратной связи принятия решения с помощью LMS-алгоритма.

dfeq = comm.DecisionFeedbackEqualizer('Algorithm','LMS', ...
    'NumForwardTaps',9,'NumFeedbackTaps',6,'ReferenceTap',5);
evm = comm.EVM('ReferenceSignalSource', ...
    'Estimated from reference constellation');

Выравнивание без корректировки входной задержки

Выравнивание полученных символов.

[y1,err1,wts1] = dfeq(rx,tx(1:numTrainingSymbols,1));

Найдите задержку между принятыми символами и переданными символами с помощью finddelay функция.

rxDelay = finddelay(tx,rx)

rxDelay = 20

Отображение информации об эквалайзере. Значение задержки указывает задержку, введенную эквалайзером. Вычислим общую задержку как сумму rxDelay и задержку эквалайзера.

eqInfo = info(dfeq)

eqInfo = struct with fields:
    Latency: 4

totalDelay = rxDelay + eqInfo.Latency;

Пока выход эквалайзера не сходится, вероятность ошибки символа высока. Постройте график выхода ошибки, err1, чтобы определить, когда выровненный выход сходится.

plot(abs(err1))
xlabel('Symbols')
ylabel('Error Magnitude')
title('Equalizer Error Signal')

Figure contains an axes. The axes with title Equalizer Error Signal contains an object of type line.

На график показаны чрезмерные ошибки для первых 2000 символов. При демодуляции символов и вычислении ошибок символов учитывайте непроверенный выход и системную задержку между выходом эквалайзера и переданными символами.

dataRec1 = pskdemod(y1(2000+totalDelay:end),M,pi/4);
symErrWithDelay = symerr(data(2000:end-totalDelay),dataRec1)

symErrWithDelay = 6001

evmWithDelay = evm(y1)

evmWithDelay = 25.6868

Вероятность ошибок и EVM высоки, потому что задержка приема не была учтена в Системный объект эквалайзера.

Настройте задержку на входе в уравнителе обратной связи принятия решения

Выравнивание полученных данных при помощи значения задержки для установки InputDelay свойство. Начиная с InputDelay является свойством nontunable, вы должны освободить dfeq Системный объект для перенастройки InputDelay свойство. Выравнивание полученных символов.

release(dfeq)
dfeq.InputDelay = rxDelay

dfeq = 
  comm.DecisionFeedbackEqualizer with properties:

                Algorithm: 'LMS'
           NumForwardTaps: 9
          NumFeedbackTaps: 6
                 StepSize: 0.0100
            Constellation: [1x4 double]
             ReferenceTap: 5
               InputDelay: 20
    InputSamplesPerSymbol: 1
    TrainingFlagInputPort: false
       AdaptAfterTraining: true
     InitialWeightsSource: 'Auto'
       WeightUpdatePeriod: 1

[y2,err2,wts2] = dfeq(rx,tx(1:numTrainingSymbols,1));

Постройте график весов отвода и выровненной величины ошибки. A диаграммы лист-ствол показывает веса отводов эквалайзера до и после удаления системной задержки. A 2D графика показывает более медленное сходимость эквалайзера для задержанного сигнала по сравнению с сигналом с удаленной задержкой.

subplot(2,1,1)
stem([real(wts1),real(wts2)])
xlabel('Taps')
ylabel('Tap Weight Real')
legend('rxDelayed','rxDelayRemoved')
grid on
subplot(2,1,2)
stem([imag(wts1),imag(wts2)])
xlabel('Taps')
ylabel('Tap Weight Imaginary')
legend('rxDelayed','rxDelayRemoved')
grid on

Figure contains 2 axes. Axes 1 contains 2 objects of type stem. These objects represent rxDelayed, rxDelayRemoved. Axes 2 contains 2 objects of type stem. These objects represent rxDelayed, rxDelayRemoved.

figure
plot([abs(err1),abs(err2)])
xlabel('Symbols')
ylabel('Error Magnitude')
legend('rxDelayed','rxDelayRemoved')
grid on

Figure contains an axes. The axes contains 2 objects of type line. These objects represent rxDelayed, rxDelayRemoved.

Постройте выход ошибок уравненных сигналов, rxDelayed и rxDelayRemoved. Для сигнала, который имеет удаленную задержку, эквалайзер сходится в течение периода обучения 1000 символов. При демодуляции символов и вычислении ошибок символов, для расчета безсовпадающего вывода и системной задержки между выходом эквалайзера и переданными символами, пропустите первые 500 символов. Перенастройка эквалайзера с учетом задержки системы позволяет лучше выравнивать сигнал и уменьшает ошибки символов и EVM.

eqInfo = info(dfeq)

eqInfo = struct with fields:
    Latency: 4

totalDelay = rxDelay + eqInfo.Latency;
dataRec2 = pskdemod(y2(500+totalDelay:end),M,pi/4);
symErrDelayRemoved = symerr(data(500:end-totalDelay),dataRec2)

symErrDelayRemoved = 0

evmDelayRemoved = evm(y2(500+totalDelay:end))

evmDelayRemoved = 7.5147

Обратная связь с решением выравнивает символы, используя обучение на основе EVM

Восстановите символы QPSK с помощью эквалайзера принятия решений, используя обучение ответвлений на основе алгоритма постоянного модуля (CMA) и EVM. При использовании алгоритмов слепого эквалайзера, таких как CMA, можно обучить отводы эквалайзера, используя AdaptWeights свойство для запуска и остановки обучения. Используйте вспомогательные функции, чтобы сгенерировать графики и применить фазу коррекцию.

Инициализируйте системные переменные.

rng(123456);
M = 4; % QPSK
numSymbols = 100;
numPackets = 5000;
refTap = 3;
nFwdTaps = 5;
nFdbkTaps = 4;
ttlTaps = nFwdTaps + nFdbkTaps;
raylChan = comm.RayleighChannel('PathDelays',[0 1], ...
    'AveragePathGains',[0 -12],'MaximumDopplerShift',1e-5);
SNR = 50;
adaptWeights = true;

Создайте объекты equalizer и EVM System. Системный объект задает эквалайзер обратной связи принятия решения с помощью адаптивного алгоритма CMA. Вызовите функцию helper, чтобы инициализировать графики рисунков.

dfeq = comm.DecisionFeedbackEqualizer('Algorithm','CMA', ...
    'NumForwardTaps',nFwdTaps,'NumFeedbackTaps',nFdbkTaps,'ReferenceTap',refTap, ...
    'StepSize',0.03,'AdaptWeightsSource','Input port')

dfeq = 
  comm.DecisionFeedbackEqualizer with properties:

                Algorithm: 'CMA'
           NumForwardTaps: 5
          NumFeedbackTaps: 4
                 StepSize: 0.0300
            Constellation: [1x4 double]
             ReferenceTap: 3
    InputSamplesPerSymbol: 1
       AdaptWeightsSource: 'Input port'
     InitialWeightsSource: 'Auto'
       WeightUpdatePeriod: 1

info(dfeq)

ans = struct with fields:
    Latency: 2

evm = comm.EVM('ReferenceSignalSource', ...
    'Estimated from reference constellation');
[errPlot,evmPlot,scatSym,adaptState] = initFigures(numPackets,ttlTaps);

Эквализация Цикла

Выполните следующие шаги, чтобы реализовать цикл эквализации.

Сгенерируйте пакеты данных OQPSK.
Примените Релеевское замирание и AWGN к данным передачи.
Примените эквализацию к полученным данным и фазе коррекцию к выходу эквалайзера.
Оцените EVM и переключите adaptWeights флаг в true или false на основе уровня EVM.
Обновите графики рисунков.

for p=1:numPackets
    data = randi([0 M-1],numSymbols,1);
    tx = pskmod(data,M,pi/4);
    rx = awgn(raylChan(tx),SNR);
    rxDelay = finddelay(rx,tx);
    [y,err,wts] = dfeq(rx,adaptWeights);
    y = phaseCorrection(y);
    evmEst = evm(y);
    adaptWeights = (evmEst > 20);
    
    updateFigures(errPlot,evmPlot,scatSym,adaptState, ...
        wts,y(end),evmEst,adaptWeights,p,numPackets)
end

Figure contains 4 axes. Axes 1 with title Tap Weight Magnitude contains an object of type stem. Axes 2 with title Scatter Plot contains an object of type line. Axes 3 with title Adapt Weights Signal contains an object of type line. Axes 4 with title EVM contains an object of type line.

rxDelay

rxDelay = 0

Графики рисунка показывают, что, когда EVM изменяется, эквалайзер переключается и выходит из направленного на принятие решения режима адаптации веса.

Вспомогательные функции

Эта вспомогательная функция инициализирует рисунки, которые показывают квадратичный график результатов симуляции.

function [errPlot,evmPlot,scatter,adaptState] = initFigures(numPkts,ttlTaps)
yVec = nan(numPkts,1);
evmVec = nan(numPkts,1);
wVec = zeros(ttlTaps,1);
adaptVec = nan(numPkts,1);

figure
subplot(2,2,1)
evmPlot = stem(wVec);
grid on; axis([1 ttlTaps 0 1.8])
xlabel('Taps'); ylabel('|Weights|'); title('Tap Weight Magnitude')

subplot(2,2,2)
scatter = plot(yVec, '.');
axis square; axis([-1.2 1.2 -1.2 1.2]); grid on
xlabel('In-phase'); ylabel('Quadrature'); title('Scatter Plot');
subplot(2,2,3)
adaptState = plot(adaptVec);
grid on; axis([0 numPkts -0.2 1.2])
ylabel('Training'); xlabel('Symbols'); title('Adapt Weights Signal')
subplot(2,2,4)
errPlot = plot(evmVec);
grid on; axis([1 numPkts 0 100])
xlabel('Symbols'); ylabel('EVM (%)'); title('EVM')
end

Эта вспомогательная функция обновляет рисунки.

function updateFigures(errPlot,evmPlot,scatSym, ...
    adaptState,w,y,evmEst,adaptWts,p,numFrames)
persistent yVec evmVec adaptVec

if p == 1
    yVec = nan(numFrames,1);
    evmVec = nan(numFrames,1);
    adaptVec = nan(numFrames,1);
end

yVec(p) = y;
evmVec(p) = evmEst;
adaptVec(p) = adaptWts;

errPlot.YData = abs(evmVec);
evmPlot.YData = abs(w);
scatSym.XData = real(yVec);
scatSym.YData = imag(yVec);
adaptState.YData = adaptVec;
drawnow limitrate
end

Эта вспомогательная функция применяет коррекцию фазы.

function y = phaseCorrection(y)
a = angle(y((real(y) > 0) & (imag(y) > 0)));
a(a < 0.1) = a(a < 0.1) + pi/2;
theta = mean(a) - pi/4;
y = y * exp(-1i*theta);
end

Обратная связь по решению выравнивает пакетированные сигналы в окружениях с замираниями

Восстановите символы QPSK в затухающих окружениях с помощью эквалайзера обратной связи принятия решения, используя алгоритм наименьших средних квадратов (LMS). Используйте reset функция объекта для выравнивания независимых пакетов. Используйте вспомогательные функции для генерации графиков. Этот пример также показывает обработку на основе символов и обработку на основе кадров.

Setup

Инициализируйте системные переменные, создайте Системный объект эквалайзера и инициализируйте рисунки графика.

M = 4; % QPSK
numSym = 1000;
numTrainingSym = 100;
numPackets = 5;
refTap = 5;
nFwdTaps = 9;
nFdbkTaps = 4;
ttlTaps = nFwdTaps + nFdbkTaps;
stepsz = 0.01;
ttlNumSym = numSym + numTrainingSym;
raylChan = comm.RayleighChannel('PathDelays',[0 1], ...
    'AveragePathGains',[0 -9], ...
    'MaximumDopplerShift',0, ...
    'PathGainsOutputPort',true);
SNR = 35;
rxVec = zeros(ttlNumSym,numPackets);
txVec = zeros(ttlNumSym,numPackets);
yVec = zeros(ttlNumSym,1);
eVec = zeros(ttlNumSym,1);

dfeq1 = comm.DecisionFeedbackEqualizer('Algorithm','LMS', ...
    'NumForwardTaps',nFwdTaps,'NumFeedbackTaps',nFdbkTaps,'ReferenceTap',refTap, ...
    'StepSize',stepsz,'TrainingFlagInputPort',true);

[errPlot,wStem,hStem,scatPlot] = initFigures(ttlNumSym,ttlTaps, ...
    raylChan.AveragePathGains);

Символьная обработка

Для обработки на основе символов предоставьте один символ на входе эквалайзера. Сбросьте состояние эквалайзера и канала после обработки каждого пакета.

for p = 1:numPackets
    trainingFlag = true;
    for q=1:ttlNumSym
        data = randi([0 M-1],1,1);
        tx = pskmod(data,M,pi/4);
        [xc,pg] = raylChan(tx);
        rx = awgn(xc,25);
        [y,err,wts] = dfeq1(rx,tx,trainingFlag);

Отключите обучение после обработки numTrainingSym обучающие символы.

        if q == numTrainingSym
            trainingFlag = false;
        end        
        updateFigures(errPlot,wStem,hStem,scatPlot,err,wts,y,pg,q,ttlNumSym);
        txVec(q,p) = tx;
        rxVec(q,p) = rx;
    end

После обработки каждого пакета сбрасывайте Системный объект канала, чтобы получить новую реализацию отводов канала, и Системный объект эквалайзера, чтобы восстановить веса отводов по умолчанию.

    reset(raylChan)
    reset(dfeq1)
end

Figure contains 4 axes. Axes 1 with title Tap Weight Magnitude contains an object of type stem. Axes 2 with title Channel Path Gain Magnitude contains an object of type stem. Axes 3 with title Error Magnitude contains an object of type line. Axes 4 with title Scatter Plot contains an object of type line.

Пакетная обработка

Для обработки на основе пакетов предоставьте один пакет на входе эквалайзера. Каждый пакет содержит ttlNumSym символы. Поскольку длительность обучения меньше, чем длина пакета, вам не нужно задавать вход начального обучения.

yVecPkt = zeros(ttlNumSym,numPackets);
errVecPkt = zeros(ttlNumSym,numPackets);
wgtVecPkt = zeros(ttlTaps,numPackets);
dfeq2 = comm.DecisionFeedbackEqualizer('Algorithm','LMS', ...
    'NumForwardTaps',nFwdTaps,'NumFeedbackTaps',nFdbkTaps,'ReferenceTap',refTap, ...
    'StepSize',stepsz);
for p = 1:numPackets
    [yVecPkt(:,p),errVecPkt(:,p),wgtVecPkt(:,p)] = ...
        dfeq2(rxVec(:,p),txVec(1:numTrainingSym,p));
    for q=1:ttlNumSym
        updateFigures(errPlot,wStem,hStem,scatPlot, ...
            errVecPkt(q,p),wgtVecPkt(:,p),yVecPkt(q,p),pg,q,ttlNumSym);
    end

    reset(raylChan)
    reset(dfeq2)
end

Вспомогательные функции

Эта вспомогательная функция инициализирует рисунки.

function [errPlot,wStem,hStem,scatPlot] = initFigures(ttlNumSym,ttlTap,pg)
yVec = nan(ttlNumSym,1);
eVec = nan(ttlNumSym,1);
wVec = zeros(ttlTap,1);
figure;
subplot(2,2,1);
wStem = stem(wVec);
axis([1 ttlTap 0 1.8]); grid on
xlabel('Taps'); ylabel('|Weights|'); title('Tap Weight Magnitude')
subplot(2,2,2);
hStem = stem([0 abs(pg) 0]);
grid on;
xlabel('Taps'); ylabel('|Path Gain|'); title('Channel Path Gain Magnitude')
subplot(2,2,3);
errPlot = plot(eVec);
axis([1 ttlNumSym 0 1.2]); grid on
xlabel('Symbols'); ylabel('|Error Magnitude|'); title('Error Magnitude')
subplot(2,2,4);
scatPlot = plot(yVec,'.');
axis square; axis([-1.2 1.2 -1.2 1.2]); grid on;
xlabel('In-phase'); ylabel('Quadrature'); title(sprintf('Scatter Plot'));
end

Эта вспомогательная функция обновляет рисунки.

function updateFigures(errPlot,wStem,hStem,scatPlot, ...
    err,wts,y,pg,p,ttlNumSym)
persistent yVec eVec
if p == 1
    yVec = nan(ttlNumSym,1);
    eVec = nan(ttlNumSym,1);
end
yVec(p) = y;
eVec(p) = abs(err);
errPlot.YData = abs(eVec);
wStem.YData = abs(wts);
hStem.YData = [0 abs(pg) 0];
scatPlot.XData = real(yVec);
scatPlot.YData = imag(yVec);
drawnow limitrate
end

Подробнее о

Интервалы между символами

Можно сконфигурировать эквалайзер так, чтобы он работал как эквалайзер с разбиением на символы или как эквалайзер с разделением на фракции символов.

Чтобы привести эквалайзер в действие со скоростью, разнесенной по символам, задайте количество выборок на символ следующим 1. Эквалайзеры со скоростью символов имеют отводы, разнесенные на длительность символа. Эквалайзеры со скоростью символов чувствительны к фазе синхронизации.
Чтобы управлять эквалайзером с разнесенной частотой дискретизации, задайте количество входа отсчетов на символ как целое число, больше 1 и обеспечивают входной сигнал с избыточной дискретизацией с этой частотой дискретизации. Дробные эквалайзеры с интервалами по символам имеют отводы, разнесенные на целую долю от длительности входного символа. Фракционные эквалайзеры с интервалами по символам не чувствительны к фазе синхронизации.

Алгоритмы