Компенсируйте модулируемые сигналы с помощью фильтрации обратной связи решения
Система comm.DecisionFeedbackEqualizer
object™ использует строку задержки касания фильтра обратной связи решения со взвешенной суммой, чтобы компенсировать модулируемые сигналы, переданные через дисперсионный канал. Объект эквалайзера адаптивно настраивает веса касания на основе выбранного алгоритма. Для получения дополнительной информации см. Алгоритмы.
Компенсировать модулируемые сигналы с помощью фильтра обратной связи решения:
Создайте объект comm.DecisionFeedbackEqualizer
и установите его свойства.
Вызовите объект с аргументами, как будто это была функция.
Чтобы узнать больше, как Системные объекты работают, смотрите то, Что Системные объекты? MATLAB.
dfe = comm.DecisionFeedbackEqualizer
dfe = comm.DecisionFeedbackEqualizer(Name,Value)
создает Системный объект эквалайзера обратной связи решения, чтобы адаптивно компенсировать сигнал.dfe
= comm.DecisionFeedbackEqualizer
свойства наборов с помощью одной или нескольких пар "имя-значение". Например, dfe
= comm.DecisionFeedbackEqualizer(Name
,Value
)comm.DecisionFeedbackEqualizer('Algorithm','RLS')
конфигурирует объект эквалайзера обновить веса касания с помощью алгоритма рекурсивных наименьших квадратов (RLS). Заключите каждое имя свойства в кавычки.
Если в противном случае не обозначено, свойства являются ненастраиваемыми, что означает, что вы не можете изменить их значения после вызова объекта. Объекты блокируют, когда вы вызываете их, и функция release
разблокировала их.
Если свойство является настраиваемым, можно изменить его значение в любое время.
Для получения дополнительной информации об изменении значений свойств смотрите Разработку системы в MATLAB Используя Системные объекты (MATLAB).
Algorithm
— Адаптивный алгоритм'LMS'
(значение по умолчанию) | 'RLS'
| 'CMA'
Адаптивный алгоритм используется для коррекции, заданной как одно из этих значений:
'LMS'
— Обновите веса касания эквалайзера с помощью Алгоритма Наименьшее количество среднего квадратичного (LMS).
'RLS'
— Обновите веса касания эквалайзера с помощью Алгоритма Рекурсивного наименьшего квадрата (RLS).
'CMA'
— Обновите веса касания эквалайзера с помощью Постоянного алгоритма модуля (CMA).
Типы данных: char | string
NumForwardTaps
— Количество прямых касаний эквалайзера5
(значение по умолчанию) | положительное целое числоКоличество прямых касаний эквалайзера, заданных как положительное целое число.
Типы данных: double
NumFeedbackTaps
— Количество касаний эквалайзера обратной связи3
(значение по умолчанию) | положительное целое числоКоличество касаний эквалайзера обратной связи, заданных как положительное целое число.
Типы данных: double
Неродной размер
Неродной размер0.01
(значение по умолчанию) | положительная скалярная величинаРазмер шага используется адаптивным алгоритмом, заданным как положительная скалярная величина. Увеличение размера шага уменьшает время сходимости эквалайзера, но заставляет эквалайзер выходные оценки быть менее стабильным.
Чтобы определить максимальный позволенный размер шага, используйте функцию объекта maxstep
.
Настраиваемый: да
Чтобы включить это свойство, установите Алгоритм на 'LMS'
или 'CMA'
.
Типы данных: double
ForgettingFactor
— Упущение фактора0.99
(значение по умолчанию) | скаляр в области значений (0, 1]Упущение фактора, используемого адаптивным алгоритмом, заданным как скаляр в области значений (0, 1]. Уменьшение фактора упущения уменьшает время сходимости эквалайзера, но заставляет эквалайзер выходные оценки быть менее стабильным.
Настраиваемый: да
Чтобы включить это свойство, установите Алгоритм на 'RLS'
.
Типы данных: double
InitialInverseCorrelationMatrix
— Начальная матрица обратной корреляции0.1
(значение по умолчанию) | скаляр | матрицаНачальная матрица обратной корреляции, заданная как скаляр или N Taps-by-NTaps матрица. Касания N равны сумме значений свойств NumForwardTaps и NumFeedbackTaps. Если вы задаете InitialInverseCorrelationMatrix
как скаляр, a, эквалайзер устанавливает начальную матрицу обратной корреляции на времена a единичная матрица: a (eye
(Касания N)).
Настраиваемый: да
Чтобы включить это свойство, установите Алгоритм на '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
флага обучения эквалайзера.
Настраиваемый: да
Типы данных: логический
AdaptAfterTraining
— Обновите веса касания если не обучениеtrue
(значение по умолчанию) | false
Обновите веса касания если не обучение, заданное как true
или false
. Если это свойство установлено в true
, Системный объект использует направленный режим решения, чтобы обновить веса касания эквалайзера. Если это свойство установлено в false
, Системный объект сохраняет веса касания эквалайзера неизменными после обучения.
Настраиваемый: да
Типы данных: логический
AdaptWeightsSource
— Источник адаптирует запрос весов касания'Property'
(значение по умолчанию) | 'Input port'
Источник адаптирует запрос весов касания, заданный как одно из этих значений:
Свойство
Задайте это значение, чтобы использовать свойство AdaptWeights управлять, когда Системный объект адаптирует веса касания.
'Input port'
— Задайте это значение, чтобы использовать вход aw
, чтобы управлять, когда Системный объект адаптирует веса касания.
Чтобы включить это свойство, установите Алгоритм на 'CMA'
.
Типы данных: char | string
AdaptWeights
— Адаптируйте веса касанияtrue
(значение по умолчанию) | false
Адаптируйте веса касания, заданные как true
или false
. Если это свойство установлено в true
, Системный объект обновляет веса касания эквалайзера. Если это свойство установлено в false
, Системный объект сохраняет веса касания эквалайзера неизменными.
Настраиваемый: да
Чтобы включить это свойство, установите AdaptWeightsSource на 'Property'
и установите AdaptAfterTraining на true
.
Типы данных: логический
InitialWeightsSource
— Источник для начальных весов касания'Auto'
(значение по умолчанию) | 'Property'
Источник для начальных весов касания, заданных как одно из этих значений:
'auto'
Инициализируйте веса касания к специфичным для алгоритма значениям по умолчанию, как описано в свойстве InitialWeights.
Свойство
Инициализируйте веса касания с помощью значения свойства InitialWeights.
Типы данных: char | string
InitialWeights
— Начальные веса0
или [0;0;1;0;0]
(значение по умолчанию) | скаляр | векторНачальные веса используются адаптивным алгоритмом, заданным как скаляр или вектор. Значением по умолчанию является 0
, когда свойство Algorithm установлено в 'LMS'
или 'RLS'
. Значением по умолчанию является [0;0;1;0;0]
, когда свойство Algorithm установлено в 'CMA'
.
Если вы задаете InitialWeights
как скаляр, эквалайзер использует скалярное расширение, чтобы создать вектор длины Касания N со всем набором значений к InitialWeights
. Касания N равны сумме значений свойств NumForwardTaps и NumFeedbackTaps. Если вы задаете InitialWeights
как вектор, длина вектора должна быть Касаниями N.
Настраиваемый: да
Типы данных: 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
,tf
)tf
. Системный объект запускает обучение, когда tf
изменяется от false
до true
(в возрастающем ребре). Train Системного объекта до всех символов в tsym
обрабатывается. Вход tsym
проигнорирован, когда tf
является false
. Чтобы включить этот синтаксис, установите свойство Algorithm на свойство 'LMS'
или 'RLS'
и TrainingFlagInputPort к true
.
также задает, адаптирует флаг y
= dfe(x
,aw
)aw
весов. Системный объект адаптирует веса касания эквалайзера, когда aw
является true
. Если aw
является false
, Системный объект сохраняет веса неизменными. Чтобы включить этот синтаксис, установите свойство Algorithm на свойство 'CMA'
и AdaptWeightsSource к 'Input port'
.
x
Входной сигналВходной сигнал, заданный как вектор-столбец. Длина вектора входного сигнала должна быть равна целочисленному кратному значение свойства InputSamplesPerSymbol. Для получения дополнительной информации смотрите, что Касание Символа Располагает с интервалами.
Типы данных: double
Поддержка комплексного числа: Да
tsym
— Учебные символыУчебные символы, заданные как вектор-столбец длины, меньше чем или равной длине входа x
. Вход tsym
проигнорирован, когда tf
является false
.
Чтобы включить этот аргумент, установите свойство Algorithm на 'LMS'
или 'RLS'
.
Типы данных: double
tf
— Trainingtrue
| false
Учебный флаг, заданный как true
или false
. Системный объект запускает обучение, когда tf
изменяется от false
до true
(в возрастающем ребре). Train Системного объекта до всех символов в tsym
обрабатывается. Вход tsym
проигнорирован, когда tf
является false
.
Чтобы включить этот аргумент, установите свойство Algorithm на свойство 'LMS'
или 'RLS'
и TrainingFlagInputPort к true
.
Типы данных: логический
aw
— Адаптируйте флаг весовtrue
| false
Адаптируйте флаг весов, заданный как true
или false
. Если aw
является true
, Системный объект адаптирует веса. Если aw
является false
, Системный объект сохраняет веса неизменными.
Чтобы включить этот аргумент, установите свойство Algorithm на свойство 'CMA'
и AdaptWeightsSource к 'Input port'
.
Типы данных: логический
y
Компенсируемые символыКомпенсируемые символы, возвращенные как вектор-столбец, который имеет ту же длину как входной сигнал x
.
err
— Сигнал ошибкиСигнал ошибки, возвращенный как вектор-столбец, который имеет ту же длину как входной сигнал x
.
weights
— Коснитесь весовКоснитесь весов, возвращенных как вектор-столбец, который имеет элементы Касаний N. Касания N равны сумме значений свойств NumForwardTaps и NumFeedbackTaps. weights
содержит веса касания от последнего обновления веса касания.
Чтобы использовать объектную функцию, задайте Системный объект как первый входной параметр. Например, чтобы выпустить системные ресурсы Системного объекта под названием obj
, используйте этот синтаксис:
release(obj)
comm.DecisionFeedbackEqualizer
isLocked | Определите, используется ли Системный объект |
clone | Создайте объект дублированной системы |
info | Характеристическая информация об объекте эквалайзера |
maxstep | Максимальный размер шага для сходимости эквалайзера LMS |
mmseweights | Линейный эквалайзер MMSE касается весов |
Создайте модулятор 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 учебных символов и 1 800 случайных символов данных. Сконфигурируйте обратную связь решения эквалайзер 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 символов обучения каждым 1 800 символам данных. Между обучением эквалайзер не обновляет веса касания. Процессы эквалайзера 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
. После каждых 2 000 символов эквалайзер переобучает касания и сохраняет, соединяют изменения канала. Постройте угловую погрешность от канала, сигнала ошибки эквалайзера и сигнального созвездия. Когда канал отличается, эквалайзер, вывод удаляет эффекты канала. Кроме того, выходная совокупность не вращается из синхронизации, и битовые ошибки уменьшаются.
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')
График показывает чрезмерные ошибки для первых 2 000 символов. При демодуляции символов и вычислительных ошибок символа, объясните не сходившийся вывод и системную задержку между эквалайзером вывод и переданными символами.
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));
Постройте веса касания и компенсируемое ошибочное значение. Диаграмма стебель-листья показывает, что веса касания эквалайзера до и после системной задержки удалены. 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
. Для сигнала, которому удалили задержку, эквалайзер сходится во время 1 000 периодов подготовки символа. Когда демодуляция символов и вычислительных ошибок символа, чтобы составлять не сходившийся вывод и системную задержку между эквалайзером вывод и переданными символами, пропускает первые 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
Можно сконфигурировать эквалайзер, чтобы действовать в качестве расположенного с интервалами символом эквалайзера или в качестве дробного расположенного с интервалами символом эквалайзера.
Чтобы управлять эквалайзером на расположенном с интервалами символом уровне, задайте количество выборок на символ как 1
. Эквалайзеры уровня символа имеют касания, расположенные с интервалами в длительности символа. Эквалайзеры уровня символа чувствительны к синхронизации фазы.
Чтобы управлять эквалайзером на дробном расположенном с интервалами символом уровне, задайте количество входных выборок на символ как целое число, больше, чем 1
, и обеспечьте входной сигнал, сверхдискретизированный на том уровне выборки. Дробные расположенные с интервалами символом эквалайзеры имеют касания, расположенные с интервалами в целочисленной части длительности вводимого символа. Дробные расположенные с интервалами символом эквалайзеры не чувствительны к синхронизации фазы.
Эквалайзер обратной связи решения (DFE) является нелинейным эквалайзером, который уменьшает интерференцию межсимвола (ISI) в выборочных частотой каналах. Если пустой указатель существует в частотной характеристике канала, DFEs не улучшают шум. DFE состоит из коснувшейся строки задержки, которая хранит выборки от входного сигнала и содержит прямой фильтр и фильтр обратной связи. Прямой фильтр подобен линейному эквалайзеру, в то время как фильтр обратной связи содержит коснувшуюся строку задержки, входные параметры которой являются решениями, принятыми о компенсируемом сигнале. Однажды на период символа, эквалайзер выводит взвешенную сумму значений в строке задержки и обновляет веса, чтобы подготовиться к следующему периоду символа.
DFEs может быть расположен с интервалами символом или дробный расположенный с интервалами символом.
Для расположенного с интервалами символом эквалайзера количество выборок на символ, K, равняется 1. Выходная частота дискретизации равняется входной частоте дискретизации.
Для дробного расположенного с интервалами символом эквалайзера количество выборок на символ, K, является целым числом, больше, чем 1. Как правило, K 4 для дробных расположенных с интервалами символом эквалайзеров. Выходная частота дискретизации является 1/T, и входной частотой дискретизации является K/T. Коснитесь обновление веса происходит при норме выработки.
Это схематические показы дробный расположенный с интервалами символом DFE в общей сложности с весами N, периодом символа T и выборками K на символ. Фильтр имеет L прямые веса и N-L веса обратной связи. Прямой фильтр наверху, и фильтр обратной связи в нижней части. Если K равняется 1, результатом является расположенный с интервалами символом DFE вместо дробного расположенного с интервалами символом DFE.
В каждый период символа эквалайзер получает выборки входа K в прямом фильтре, а также одно решение или учебную выборку в фильтре обратной связи. Эквалайзер затем выводит взвешенную сумму значений в форварде и строках задержки обратной связи и обновляет веса, чтобы подготовиться к следующему периоду символа.
Алгоритм для блока Adaptive Algorithm в схематическом совместно оптимизирует веса обратной связи и форвард. Объединенная оптимизация особенно важна для алгоритма RLS.
Для получения дополнительной информации смотрите Коррекцию.
Для LMS-алгоритма, относясь к предыдущему схематическому, w является вектором всех весов wi, и u является вектором всех входных параметров ui. На основе текущего набора весов LMS-алгоритм создает новый набор весов как
w, новый = w, текущий + (StepSize) u *e.
Размер шага, используемый адаптивным алгоритмом, задан как положительная скалярная величина. Увеличение размера шага уменьшает время сходимости эквалайзера, но заставляет компенсируемый выходной сигнал быть менее стабильным. Чтобы определить максимальный размер шага, позволенный при использовании адаптивного алгоритма LMS, используйте функцию объекта maxstep
. Оператор * обозначает сопряженное комплексное число и ошибочное вычисление e = d - y.
Для алгоритма RLS, относясь к предыдущему схематическому, w является вектором всех весов wi, и u является вектором всех входных параметров ui. На основе текущего набора входных параметров, u, и матрицы обратной корреляции, P, алгоритм RLS сначала вычисляет вектор усиления Кальмана, K, как
Фактор упущения, используемый адаптивным алгоритмом, задан как скаляр в области значений (0, 1]. Уменьшение фактора упущения уменьшает время сходимости эквалайзера, но заставляет компенсируемый выходной сигнал быть менее стабильным. H обозначает, что Эрмитовы транспонируют. На основе текущей матрицы обратной корреляции новая матрица обратной корреляции
На основе текущего набора весов алгоритм RLS создает новый набор весов как
w, новый = w current+K*e.
Оператор * обозначает сопряженное комплексное число и ошибочное вычисление e = d - y.
Для CMA адаптивный алгоритм, относясь к предыдущему схематическому, w является вектором всех весов wi, и u является вектором всех входных параметров ui. На основе текущего набора весов CMA адаптивный алгоритм создает новый набор весов как
w, новый = w, текущий + (StepSize) u *e.
Размер шага, используемый адаптивным алгоритмом, задан как положительная скалярная величина. Увеличение размера шага уменьшает время сходимости эквалайзера, но заставляет компенсируемый выходной сигнал быть менее стабильным. Чтобы определить максимальный размер шага, позволенный CMA адаптивный алгоритм, используйте функцию объекта maxstep
. Оператор * обозначает сопряженное комплексное число и ошибочное вычисление e = y (R - |y|2), где R является константой, связанной с сигнальным созвездием.
1. Если смысл перевода понятен, то лучше оставьте как есть и не придирайтесь к словам, синонимам и тому подобному. О вкусах не спорим.
2. Не дополняйте перевод комментариями “от себя”. В исправлении не должно появляться дополнительных смыслов и комментариев, отсутствующих в оригинале. Такие правки не получится интегрировать в алгоритме автоматического перевода.
3. Сохраняйте структуру оригинального текста - например, не разбивайте одно предложение на два.
4. Не имеет смысла однотипное исправление перевода какого-то термина во всех предложениях. Исправляйте только в одном месте. Когда Вашу правку одобрят, это исправление будет алгоритмически распространено и на другие части документации.
5. По иным вопросам, например если надо исправить заблокированное для перевода слово, обратитесь к редакторам через форму технической поддержки.