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

lineq = comm.LinearEqualizer создает линейный Системный объект эквалайзера, чтобы адаптивно компенсировать сигнал.

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

Свойства

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

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

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

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

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

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

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

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

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

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

`Неродной размер` Неродной размер
`0.01` (значение по умолчанию) | положительная скалярная величина

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

Совет

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

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

Зависимости

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

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

`ForgettingFactor` — Упущение фактора
`0.99` (значение по умолчанию) | скаляр в области значений (0, 1]

Упущение фактора, используемого адаптивным алгоритмом, заданным как скаляр в области значений (0, 1]. Уменьшение фактора упущения уменьшает время сходимости эквалайзера, но заставляет эквалайзер выходные оценки быть менее стабильным.

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

Зависимости

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

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

`InitialInverseCorrelationMatrix` — Начальная матрица обратной корреляции
`0.1` (значение по умолчанию) | скаляр | матрица

Начальная матрица обратной корреляции, заданная как скаляр или N _{Taps-by-NTaps} матрица. _{Касания} N равны значению свойства NumTaps. Если вы задаете 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` (значение по умолчанию) | положительное целое число

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

Типы данных: 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 как вектор, длина вектора должна быть равна значению свойства NumTaps. Если вы задаете InitialWeights как скаляр, эквалайзер использует скалярное расширение, чтобы создать вектор длины NumTaps со всем набором значений к InitialWeights.

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

Зависимости

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

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

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

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

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

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

Синтаксис

y = lineq(x,tsym)

y = lineq(x,tsym,tf)

y = lineq(x)

y = lineq(x,aw)

Описание

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

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

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

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

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

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

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

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

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

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

`tsym` — Учебные символы
вектор-столбец

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

Зависимости

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

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

Флаг `tf` — Training
`true` | `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` — Коснитесь весов
вектор-столбец

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

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

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

release(obj)

Характерный для comm.LinearEqualizer

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

Характерный для всех системных объектов

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

Примеры

Линейно компенсируйте модулируемый BPSK сигнал

Создайте модулятор 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));

Линейно компенсируйте модулируемый QPSK сигнал

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

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

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

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

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

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

eq = comm.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. Примените различные планы подготовки эквалайзера и покажите ошибочное значение символа.

Системный 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;
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 символов обучения каждым 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(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. После каждых 2 000 символов эквалайзер переобучает касания и сохраняет, соединяют изменения канала. Постройте угловую погрешность от канала, сигнала ошибки эквалайзера и сигнального созвездия. Когда канал отличается, эквалайзер, вывод удаляет эффекты канала. Кроме того, выходная совокупность не вращается из синхронизации, и битовые ошибки уменьшаются.

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. Системный объект эквалайзера задает линейный эквалайзер с помощью 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')

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

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));

Постройте веса касания и компенсируемое ошибочное значение. Диаграмма стебель-листья показывает, что веса касания эквалайзера до и после системной задержки удалены. 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(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

Линейно компенсируйте символы Используя основанное на EVM обучение

Восстановите символы 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. Системный объект эквалайзера задает линейный эквалайзер с помощью 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

Линейно компенсируйте сигналы Packetized в исчезающих средах

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

Настройка

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

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 для calulate решение для минимальной среднеквадратической ошибки (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)

Больше о

Интервал касания символа

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

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

Алгоритмы