Выравнивание модулированных сигналов с помощью линейной фильтрации
comm.LinearEqualizer Система object™ использует линейную линию задержки отвода фильтра со взвешенной суммой для выравнивания модулированных сигналов, передаваемых по дисперсионному каналу. Объект эквалайзера адаптивно регулирует веса отводов на основе выбранного алгоритма. Дополнительные сведения см. в разделе Алгоритмы.
Для выравнивания модулированных сигналов с помощью линейного фильтра:
Создать comm.LinearEqualizer и задайте его свойства.
Вызовите объект с аргументами, как если бы это была функция.
Дополнительные сведения о работе системных объектов см. в разделе Что такое системные объекты?.
lineq = comm.LinearEqualizer
lineq = comm.LinearEqualizer(Name,Value)comm.LinearEqualizer('Algorithm','RLS') конфигурирует объект эквалайзера для обновления весов отводов с использованием алгоритма рекурсивных наименьших квадратов (RLS). Заключите каждое имя свойства в кавычки.
y = lineq(x,tsym,tf)tf. Объект System начинает обучение, когда tf изменения из false кому true (у переднего края). Объект System проходит до тех пор, пока все символы в tsym обрабатываются. Вход tsym игнорируется, когда tf является false. Чтобы включить этот синтаксис, задайте для свойства Algorithm значение 'LMS' или 'RLS' и свойство TrainingFlagInputPort для true.
y = lineq(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; eqlms = comm.LinearEqualizer('Algorithm','LMS','NumTaps',8,'StepSize',0.03);
Измените индекс опорного ответвления эквалайзера.
eqlms.ReferenceTap = 4;
Создайте набор тестовых данных. Прием данных путем свертки сигнала.
x = bpsk(randi([0 1],1000,1)); rxsig = conv(x,[1 0.8 0.3]);
Использовать maxstep для поиска максимально допустимого размера шага.
mxStep = maxstep(eqlms,rxsig)
mxStep = 0.1384
Выровнять принятый сигнал. Используйте первые 200 символов в качестве обучающей последовательности.
y = eqlms(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.LinearEqualizer
eq =
comm.LinearEqualizer with properties:
Algorithm: 'LMS'
NumTaps: 5
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.3154
[y,err,weights] = eq(rx,tx(1:numTrainingSymbols));
Постройте график созвездия нарушенных и выровненных символов.
constell = comm.ConstellationDiagram('NumInputPorts',2);
constell(rx,y)
Постройте график сигнала ошибки эквалайзера и вычислите величину вектора ошибки (EVM) выровненных символов.
plot(abs(err)) grid on; xlabel('Symbols'); ylabel('|e|');title('Equalizer Error Signal')
errevm = comm.EVM; evm = errevm(tx,y)
evm = 11.7710
Постройте график весов отводов эквалайзера.
subplot(3,1,1); stem(real(weights)); ylabel('real(weights)'); xlabel('Tap'); grid on; axis([0 6 -0.5 1]) title('Equalizer Tap Weights') subplot(3,1,2); stem(imag(weights)); ylabel('imag(weights)'); xlabel('Tap'); grid on; axis([0 6 -0.5 1]) subplot(3,1,3); stem(abs(weights)); ylabel('abs(weights)'); xlabel('Tap'); grid on; axis([0 6 -0.5 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; lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'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] = lineq(rx,trainingSymbols); reset(lineq) if (ii ==1 || ii == 2 ||ii == numPkts) subplot(3,1,jj) plot(abs(err)) title(['Packet # ',num2str(ii)]) xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on; jj = jj+1; end end
Обучение эквалайзера в начале каждого пакета без сброса
Обработка каждого пакета с использованием добавочных обучающих символов. Не сбрасывайте эквалайзер после обработки каждого пакета. Не сбрасывая после каждого пакета, эквалайзер сохраняет веса отводов от предыдущих пакетов. Графики сигнала ошибки эквалайзера для первого, второго и последнего пакета показывают, что после начальной тренировки по первому пакету последующие пакеты имеют меньшее количество символьных ошибок в начале каждого пакета.
release(lineq) 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] = lineq(rx,trainingSymbols); if (ii ==1 || ii == 2 ||ii == numPkts) subplot(3,1,jj) plot(abs(err)) title(['Packet # ',num2str(ii)]) xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) 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(lineq) lineq.AdaptAfterTraining = false
lineq =
comm.LinearEqualizer with properties:
Algorithm: 'LMS'
NumTaps: 5
StepSize: 0.0100
Constellation: [1x4 double]
ReferenceTap: 3
InputDelay: 0
InputSamplesPerSymbol: 1
TrainingFlagInputPort: false
AdaptAfterTraining: false
InitialWeightsSource: 'Auto'
WeightUpdatePeriod: 1
Выровнять поврежденные данные. Постройте график угловой ошибки из канала, сигнала ошибки эквалайзера и совокупности сигналов. При изменении канала выходной сигнал эквалайзера не удаляет эффекты канала. Выходная совокупность вращается несинхронизированно, что приводит к битовым ошибкам.
[y,err] = lineq(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(lineq) lineq.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)] = ... lineq(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. Объект equalizer System определяет линейный эквалайзер, использующий алгоритм LMS.
lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',9,'ReferenceTap',5); evm = comm.EVM('ReferenceSignalSource', ... 'Estimated from reference constellation');
Уравнять без регулировки задержки на входе
Выравнивание полученных символов.
[y1,err1,wts1] = lineq(rx,tx(1:numTrainingSymbols,1));
Найдите задержку между принятыми символами и переданными символами с помощью finddelay функция.
rxDelay = finddelay(tx,rx)
rxDelay = 20
Просмотрите информацию эквалайзера. Значение задержки указывает задержку, введенную корректором. Вычислить общую задержку как сумму rxDelay и задержка эквалайзера.
eqInfo = info(lineq)
eqInfo = struct with fields:
Latency: 4
totalDelay = rxDelay + eqInfo.Latency;
Пока выходной сигнал эквалайзера не сойдется, частота ошибок символов высока. Постройте график вывода ошибки, err1, чтобы определить, когда выравниваемый выходной сигнал сходится.
plot(abs(err1)) xlabel('Symbols') ylabel('Error Magnitude') title('Equalizer Error Signal')
График показывает чрезмерные ошибки за пределами периода обучения 1000 символов. При демодуляции символов и вычислении ошибок символов, чтобы учесть несвергнутый выходной сигнал и системную задержку между выходным сигналом эквалайзера и переданными символами, пропускают первые 2000 символов.
dataRec1 = pskdemod(y1(2000+totalDelay:end),M,pi/4); symErrWithDelay = symerr(data(2000:end-totalDelay),dataRec1)
symErrWithDelay = 5999
evmWithDelay = evm(y1)
evmWithDelay = 29.5795
Частота ошибок и EVM высоки, поскольку задержка приема не была учтена в системном объекте эквалайзера.
Настройка задержки на входе в эквалайзере
Выравнивание полученных данных с помощью значения задержки для установки InputDelay собственность. Поскольку InputDelay является неперестраиваемым свойством, необходимо освободить lineq Системный объект для изменения конфигурации InputDelay собственность. Выравнивание полученных символов.
release(lineq) lineq.InputDelay = rxDelay
lineq =
comm.LinearEqualizer with properties:
Algorithm: 'LMS'
NumTaps: 9
StepSize: 0.0100
Constellation: [1x4 double]
ReferenceTap: 5
InputDelay: 20
InputSamplesPerSymbol: 1
TrainingFlagInputPort: false
AdaptAfterTraining: true
InitialWeightsSource: 'Auto'
WeightUpdatePeriod: 1
[y2,err2,wts2] = lineq(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(lineq)
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 = 9.4435
Восстановление символов QPSK с помощью линейного эквалайзера с использованием алгоритма постоянного модуля (CMA) и обучения отводам на основе EVM. При использовании алгоритмов слепого эквалайзера, таких как CMA, обучайте отводы эквалайзера с помощью AdaptWeights свойство для запуска и остановки обучения. Вспомогательные функции используются для создания графиков и применения фазовой коррекции.
Инициализация системных переменных.
rng(123456); M = 4; % QPSK numSymbols = 100; numPackets = 5000; raylChan = comm.RayleighChannel('PathDelays',[0 1], ... 'AveragePathGains',[0 -12],'MaximumDopplerShift',1e-5); SNR = 50; adaptWeights = true;
Создайте объекты эквалайзера и системы EVM. Объект equalizer System определяет линейный эквалайзер с помощью адаптивного алгоритма CMA. Вызовите вспомогательную функцию для инициализации рисунков.
lineq = comm.LinearEqualizer('Algorithm','CMA', ... 'NumTaps',5,'ReferenceTap',3, ... 'StepSize',0.03,'AdaptWeightsSource','Input port')
lineq =
comm.LinearEqualizer with properties:
Algorithm: 'CMA'
NumTaps: 5
StepSize: 0.0300
Constellation: [1x4 double]
ReferenceTap: 3
InputSamplesPerSymbol: 1
AdaptWeightsSource: 'Input port'
InitialWeightsSource: 'Auto'
WeightUpdatePeriod: 1
info(lineq)
ans = struct with fields:
Latency: 2
evm = comm.EVM('ReferenceSignalSource', ... 'Estimated from reference constellation'); [errPlot,evmPlot,scatSym,adaptState] = initFigures(numPackets,lineq);
Контур выравнивания
Для реализации цикла выравнивания:
Создание пакетов данных PSK.
Примените к данным передачи релеевское замирание и 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] = lineq(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,lineq) yVec = nan(numPkts,1); evmVec = nan(numPkts,1); wVec = zeros(lineq.NumTaps,1); adaptVec = nan(numPkts,1); figure subplot(2,2,1) evmPlot = stem(wVec); grid on; axis([1 lineq.NumTaps 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 объектная функция для выравнивания независимых пакетов. Используйте вспомогательные функции для создания графиков. Этот пример также показывает обработку на основе символов и обработку на основе кадров.
Установка
Инициализируйте системные переменные, создайте объект equalizer System и инициализируйте рисунки.
M = 4; % QPSK numSym = 1000; numTrainingSym = 100; numPackets = 5; numTaps = 9; 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); lineq1 = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',numTaps,'ReferenceTap',5, ... 'StepSize',0.01,'TrainingFlagInputPort',true); [errPlot,wStem,hStem,scatPlot] = initFigures(ttlNumSym,lineq1, ... 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] = lineq1(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(lineq1)
end
Обработка на основе пакетов
Для обработки на основе пакетов предоставьте один пакет на входе эквалайзера. Каждый пакет содержит ttlNumSym символы. Поскольку продолжительность обучения меньше длины пакета, нет необходимости указывать вводимые данные для начала обучения.
yVecPkt = zeros(ttlNumSym,numPackets); errVecPkt = zeros(ttlNumSym,numPackets); wgtVecPkt = zeros(numTaps,numPackets); lineq2 = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',9,'ReferenceTap',6,'StepSize',0.01); for p = 1:numPackets [yVecPkt(:,p),errVecPkt(:,p),wgtVecPkt(:,p)] = ... lineq2(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(lineq2)
end
Вспомогательные функции
Вспомогательная функция инициализирует фигуры.
function [errPlot,wStem,hStem,scatPlot] = initFigures(ttlNumSym,lineq,pg) yVec = nan(ttlNumSym,1); eVec = nan(ttlNumSym,1); wVec = zeros(lineq.NumTaps,1); figure; subplot(2,2,1); wStem = stem(wVec); axis([1 lineq.NumTaps 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
Линейный эквалайзер используется в неадаптивном режиме. Используйте mmseweights объектная функция для вычисления решения минимальной среднеквадратичной ошибки (MMSE) и использования весов, возвращаемых в качестве набора весов отводов для линейного эквалайзера.
Инициализация переменных моделирования.
M = 4; % QPSK
numSymbols = 10000;
numTrainingSymbols = 1000;
chtaps = [1 0.5*exp(1i*pi/6) 0.1*exp(-1i*pi/8)];
EbN0 = 20;Создание модулированных символов QPSK. Примените к символам задержанную фильтрацию каналов многолучевого распространения и ухудшение AWGN.
data = randi([0 M-1], numSymbols, 1);
tx = pskmod(data, M, pi/4);
rx = awgn(filter(chtaps,1,tx),25,'measured');Создайте объект системы линейного эквалайзера, сконфигурированный для использования алгоритма CMA, установите AdaptWeights свойство для false, и InitialWeightsSource свойство для Property. Рассчитайте веса MMSE. Установите для начальных весов отводов рассчитанные весовые коэффициенты MMSE. Выровнять поврежденные символы.
eq = comm.LinearEqualizer('Algorithm','CMA','AdaptWeights',false,'InitialWeightsSource','Property')
eq =
comm.LinearEqualizer with properties:
Algorithm: 'CMA'
NumTaps: 5
StepSize: 0.0100
Constellation: [1x4 double]
InputSamplesPerSymbol: 1
AdaptWeightsSource: 'Property'
AdaptWeights: false
InitialWeightsSource: 'Property'
InitialWeights: [5x1 double]
WeightUpdatePeriod: 1
wgts = mmseweights(eq,chtaps,EbN0)
wgts = 5×1 complex
0.0005 - 0.0068i
0.0103 + 0.0117i
0.9694 - 0.0019i
-0.3987 + 0.2186i
0.0389 - 0.1756i
eq.InitialWeights = wgts; [y,err,weights] = eq(rx);
Печать совокупности нарушенных и выровненных символов.
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 = 140.6177
Печать весов отводов эквалайзера.
subplot(3,1,1); stem(real(weights)); ylabel('real(weights)'); xlabel('Tap'); grid on; axis([1 8 -0.5 1]) line([eq.NumTaps+0.5 eq.NumTaps+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.NumTaps+0.5 eq.NumTaps+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.NumTaps+0.5 eq.NumTaps+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; lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'ReferenceTap',3,'StepSize',0.01,'TrainingFlagInputPort',true);
Основной контур
Используйте символы предварительного обучения при обработке каждого пакета. После обработки каждого пакета выполните сброс эквалайзера. Этот сброс заставляет эквалайзер обучать отводы без предварительного знания. Уравнять выборку принимаемого сигнала по выборке. Для каждого пакета используйте первые 200 символов для обучения.
subPlotCnt = 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); y = zeros(numDataSymbols+numTrainSymbols,1); err = zeros(numDataSymbols+numTrainSymbols,1); for jj = 1:numDataSymbols+numTrainSymbols if jj <= numTrainSymbols [y(jj),err(jj)] = lineq(rx(jj),trainingSymbols(jj),true); else [y(jj),err(jj)] = lineq(rx(jj),1i,false); end end reset(lineq) if (ii ==1 || ii == 2 ||ii == numPkts) subplot(3,1,subPlotCnt) plot(abs(err)) title(['Packet # ',num2str(ii)]) xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on; subPlotCnt = subPlotCnt+1; end end
Продемонстрировать линейное выравнивание с использованием алгоритма наименьших средних квадратов (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); b = randi([0 M-1],numDataSymbols,1); dataSym = pskmod(b,M,pi/4); packet = [trainingSymbols;dataSym]; rx = awgn(packet,SNR); lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'ReferenceTap',3,'StepSize',0.01);
Обработка пакета за один проход
Используйте символы предварительного обучения при обработке каждого пакета. После обработки каждого пакета выполните сброс эквалайзера. Этот сброс заставляет эквалайзер обучать отводы без предварительного знания. Уравнять выборку принимаемого сигнала по выборке. Для каждого пакета используйте первые 200 символов для обучения.
subPlotCnt = 1; figure [y1,err1] = lineq(rx,trainingSymbols); reset(lineq) plot(abs(err1)) title("Single Pass Processing") xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on;
Обработка пакета в нескольких проходах
Используйте символы предварительного обучения при обработке каждого пакета. После обработки каждого пакета выполните сброс эквалайзера. Этот сброс заставляет эквалайзер обучать отводы без предварительного знания. Уравнять выборку принимаемого сигнала по выборке. Для каждого пакета используйте первые 200 символов для обучения.
lineq = comm.LinearEqualizer('Algorithm','LMS', ... 'NumTaps',5,'ReferenceTap',3,'StepSize',0.01,'TrainingFlagInputPort',true); frameLen = 100; numFrames = (numDataSymbols+numTrainSymbols) / frameLen; figure y2 = zeros(numDataSymbols+numTrainSymbols,1); err2 = zeros(numDataSymbols+numTrainSymbols,1); idx = 1:frameLen; symbolCnt = 0; for jj = 1:numFrames if symbolCnt < numTrainSymbols [y2(idx),err2(idx)] = lineq(rx(idx),trainingSymbols(idx),true); else [y2(idx),err2(idx)] = lineq(rx(idx),1i*ones(frameLen,1),false); end idx = idx + frameLen; symbolCnt = symbolCnt + frameLen; end reset(lineq) plot(abs(err2)) title("Multipass Processing") xlabel('Symbols') ylabel('Error Magnitude') axis([0,length(packet),0,1]) grid on;
Результаты выравнивания с использованием однопроходных и многопроходных подходов совпадают.
outputsEqual = isequal(y1,y2)
outputsEqual = logical
1
errorsEqual = isequal(err1,err2)
errorsEqual = logical
1
Линейные эквалайзеры могут удалять межсимвольные помехи (ISI), когда частотная характеристика канала не имеет нуля. Если в частотной характеристике канала имеется нулевое значение, линейные эквалайзеры стремятся усилить шум. В этом случае используйте корректоры обратной связи принятия решения, чтобы избежать усиления шума.
Линейный эквалайзер состоит из отводимой линии задержки, которая хранит выборки из входного сигнала. Один раз за период символа эквалайзер выводит взвешенную сумму значений в линии задержки и обновляет веса для подготовки к следующему периоду символа.
Линейные эквалайзеры могут быть разнесенными по символам или дробными по символам.
Для эквалайзера с разнесением символов число выборок на символ K равно 1. Выходная частота дискретизации равна входной частоте дискретизации.
Для эквалайзера с дробными символами число выборок на символ, K, равно целому числу, большему 1. Обычно К равно 4 для дробно разнесенных эквалайзеров. Выходная частота дискретизации равна 1/T, а входная частота дискретизации равна K/T, где T - период символа. Обновление веса отводов происходит с частотой вывода.
На этой схеме показан линейный эквалайзер с L весами, периодом символа Т и К выборок на символ. Если K равно 1, то результатом является линейный эквалайзер с интервалом символов вместо линейного эквалайзера с интервалом дробных символов.
В каждом периоде символа эквалайзер принимает K входных выборок на линии задержки с отводом. Затем эквалайзер выводит взвешенную сумму значений в линии задержки с отводом и обновляет веса для подготовки к следующему периоду символа.
Дополнительные сведения см. в разделе Уравнение.