Выравнивание модулированных сигналов с помощью фильтрации с обратной связью принятия решений
comm.DecisionFeedbackEqualizer Система object™ использует линию задержки отвода фильтра с обратной связью принятия решения со взвешенной суммой для выравнивания модулированных сигналов, передаваемых по дисперсионному каналу. Объект эквалайзера адаптивно регулирует веса отводов на основе выбранного алгоритма. Дополнительные сведения см. в разделе Алгоритмы.
Для выравнивания модулированных сигналов с использованием фильтра обратной связи принятия решения:
Создать comm.DecisionFeedbackEqualizer и задайте его свойства.
Вызовите объект с аргументами, как если бы это была функция.
Дополнительные сведения о работе системных объектов см. в разделе Что такое системные объекты?.
dfe = comm.DecisionFeedbackEqualizer
dfe = comm.DecisionFeedbackEqualizer(Name,Value)comm.DecisionFeedbackEqualizer('Algorithm','RLS') конфигурирует объект эквалайзера для обновления весов отводов с использованием алгоритма рекурсивных наименьших квадратов (RLS). Заключите каждое имя свойства в кавычки.
y = dfe(x,tsym,tf)tf. Объект System начинает обучение, когда tf изменения из false кому true (у переднего края). Объект System проходит до тех пор, пока все символы в tsym обрабатываются. Вход tsym игнорируется, когда tf является false. Чтобы включить этот синтаксис, задайте для свойства Algorithm значение 'LMS' или 'RLS' и свойство TrainingFlagInputPort для true.
y = dfe(x,aw)aw. Объект System адаптирует веса отводов эквалайзера, когда aw является true. Если aw является false, объект System сохраняет веса неизменными. Чтобы включить этот синтаксис, задайте для свойства Algorithm значение 'CMA' и собственность AdaptWeightsSource к 'Input port'.
Чтобы использовать функцию объекта, укажите объект System в качестве первого входного аргумента. Например, для освобождения системных ресурсов объекта System с именем obj, используйте следующий синтаксис:
release(obj)
Создайте модулятор 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));
Применение выравнивания обратной связи принятия решения с использованием алгоритма наименьших средних квадратов (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)
Постройте график сигнала ошибки эквалайзера и вычислите величину вектора ошибки выровненных символов.
plot(abs(err)) grid on; xlabel('Symbols'); ylabel('|e|')
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)
Продемонстрировать выравнивание обратной связи при принятии решения с использованием алгоритма наименьших средних квадратов (LMS) для восстановления символов QPSK, прошедших через канал AWGN. Примените различные схемы обучения эквалайзера и покажите величину ошибки символа.
Настройка системы
Моделирование 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
Обучение эквалайзера в начале каждого пакета без сброса
Обработка каждого пакета с использованием добавочных обучающих символов. Не сбрасывайте эквалайзер после обработки каждого пакета. Не сбрасывая после каждого пакета, эквалайзер сохраняет веса отводов от предыдущих пакетов. Графики сигнала ошибки эквалайзера для первого, второго и последнего пакета показывают, что после начальной тренировки по первому пакету последующие пакеты имеют меньше символьных ошибок в начале каждого пакета.
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')
scatterplot(y)
Установите 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')
scatterplot(yVec)
Моделирование системы с задержкой между переданными символами и принятыми выборками. Типичные системы имеют фильтры передатчика и приемника, которые приводят к задержке. Эта задержка должна быть учтена для синхронизации системы. В этом примере системная задержка вводится без фильтров передачи и приема. Выравнивание обратной связи принятия решения, используя алгоритм наименьших средних квадратов (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');
Создайте объекты эквалайзера и системы EVM. Объект системы эквалайзера определяет эквалайзер обратной связи принятия решения с использованием алгоритма 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')
График показывает чрезмерные ошибки для первых 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 является неперестраиваемым свойством, необходимо освободить 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));
Постройте график весов отводов и выровненной величины ошибки. Блок-график показывает веса отводов эквалайзера до и после удаления системной задержки. График линии 2-D показывает более медленную конвергенцию эквалайзера для задержанного сигнала по сравнению с сигналом с удаленной задержкой.
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 plot([abs(err1),abs(err2)]) xlabel('Symbols') ylabel('Error Magnitude') legend('rxDelayed','rxDelayRemoved') grid on
Вывод ошибки графика уравниваемых сигналов, 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
Восстановление символов 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;
Создайте объекты эквалайзера и системы EVM. Системный объект эквалайзера определяет эквалайзер обратной связи принятия решения с использованием адаптивного алгоритма CMA. Вызовите вспомогательную функцию для инициализации рисунков.
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
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 объектная функция для выравнивания независимых пакетов. Используйте вспомогательные функции для создания графиков. Этот пример также показывает обработку на основе символов и обработку на основе кадров.
Установка
Инициализируйте системные переменные, создайте системный объект эквалайзера и инициализируйте рисунки.
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
Обработка на основе пакетов
Для обработки на основе пакетов предоставьте один пакет на входе эквалайзера. Каждый пакет содержит 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
Эквалайзер обратной связи принятия решения (DFE) является нелинейным эквалайзером, который уменьшает межсимвольные помехи (ISI) в частотно-селективных каналах. Если в частотной характеристике канала имеется значение null, то DFE не повышают уровень шума. DFE состоит из отводимой линии задержки, которая хранит выборки из входного сигнала и содержит прямой фильтр и фильтр обратной связи. Прямой фильтр подобен линейному эквалайзеру. Фильтр обратной связи содержит отводимую линию задержки, входами которой являются решения, принятые по выровненному сигналу. Один раз за период символа эквалайзер выводит взвешенную сумму значений в линии задержки и обновляет веса для подготовки к следующему периоду символа.
DFE могут быть разнесенными по символам или дробными по символам.
Для эквалайзера с разнесением символов число выборок на символ K равно 1. Выходная частота дискретизации равна входной частоте дискретизации.
Для эквалайзера с дробными символами число выборок на символ, K, равно целому числу, большему 1. Обычно K равно 4 для дробных эквалайзеров, разнесенных по символам. Выходная частота дискретизации равна 1/T, а входная частота дискретизации равна K/T. Обновление веса отводов происходит с частотой вывода.
На этой схеме показан разделенный на части DFE с общим числом N весов, периодом символа T и K выборок на символ. Фильтр имеет L весов прямой связи и N-L весов обратной связи. Прямой фильтр находится вверху, а фильтр обратной связи - внизу. Если K равно 1, то результатом является DFE с разнесением по символам вместо DFE с разделением по символам.
В каждом периоде символа эквалайзер принимает K входных выборок в прямом фильтре и одну решающую или обучающую выборку в фильтре обратной связи. Затем эквалайзер выводит взвешенную сумму значений в прямых линиях задержки и линиях задержки обратной связи и обновляет весовые коэффициенты для подготовки к следующему периоду символа.
Примечание
Алгоритм для блока «Адаптивный алгоритм» в схеме совместно оптимизирует веса прямой и обратной связи. Совместная оптимизация особенно важна для сходимости в алгоритме рекурсивного наименьшего квадрата (RLS).
Дополнительные сведения см. в разделе Уравнение.