Выравнивание модулированных сигналов с помощью фильтрации обратной связи принятия решений
The comm.DecisionFeedbackEqualizer Система object™ использует линию задержки отвода фильтра обратной связи принятия решения с взвешенной суммой, чтобы выровнять модулированные сигналы, переданные через дисперсионный канал. Объект эквалайзера адаптивно настраивает веса отводов на основе выбранного алгоритма. Для получения дополнительной информации см. «Алгоритмы».
Для выравнивания модулированных сигналов с помощью фильтра обратной связи принятия решения:
Создайте comm.DecisionFeedbackEqualizer Объекту и установите его свойства.
Вызывайте объект с аргументами, как будто это функция.
Дополнительные сведения о работе системных объектов см. в разделе «Что такое системные объекты?».
dfe = comm.DecisionFeedbackEqualizer
dfe = comm.DecisionFeedbackEqualizer(Name,Value)comm.DecisionFeedbackEqualizer('Algorithm','RLS') конфигурирует объект эквалайзера для обновления весов отводов с помощью рекурсивного алгоритма наименьших квадратов (RLS). Заключайте каждое имя свойства в кавычки.
y = dfe(x,tsym,tf)tf. Обучение Системного объекта начинает, когда tf изменения от false на true (на переднем ребре). Системный объект обучается до тех пор, пока все символы не будут tsym обрабатываются. Область входа tsym игнорируется, когда tf является false. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'LMS' или 'RLS' и свойство TrainingFlagInportPort в true.
y = dfe(x,aw)aw. Системный объект адаптирует веса ответвлений эквалайзера при aw является true. Если aw является falseСистемный объект сохраняет веса неизменными. Чтобы включить этот синтаксис, задайте значение свойства Algorithm 'CMA' и свойство AdaptWeightsSource к 'Input port'.
Чтобы использовать функцию объекта, задайте системный объект в качестве первого входного параметра. Например, чтобы освободить системные ресурсы системного объекта с именем 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. Примените различные схемы обучения эквалайзера и отобразите величину ошибки символа.
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
Обучите эквалайзер в начале каждого пакета без сброса
Обработайте каждый пакет с помощью предварительно настроенных обучающих символов. Не сбрасывайте эквалайзер после обработки каждого пакета. Не сбрасывая после каждого пакета, эквалайзер сохраняет веса отводов от обучающих предыдущих пакетов. Сигнал ошибки эквалайзера, графиков для первого, второго и последнего пакета, показывает, что после начального обучения на первом пакете последующие пакеты имеют меньше символьных ошибок в начале каждого пакета.
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');
Создайте объекты 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')
На график показаны чрезмерные ошибки для первых 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 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;
Создайте объекты 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
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
Пакетная обработка
Для обработки на основе пакетов предоставьте один пакет на входе эквалайзера. Каждый пакет содержит 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).
Для получения дополнительной информации см. «Эквализация».