Задержитесь как система свертки

Целочисленные задержки задержек

Рассмотрите задержку цифрового сигнала, $y[n]=x[n-D]$ где D является целым числом. Эта операция может быть представлена как фильтр свертки $$y=h*x$$, с конечной импульсной характеристикой $\mathit{h}\left[\mathit{n}\right]=\delta \left[\mathit{n}-\mathit{D}\right]$. Соответствующая передаточная функция $$H(z)=z^{-D}$$, и frequeny ответ $\mathit{H}\left(\omega \right)={\mathit{e}}^{-\mathit{i}\omega \mathit{D}}$. Программно, можно реализовать такой целочисленный фильтр задержки с помощью следующего кода MATLAB®.

% Create the FIR
D = 3; % Delay value
h = [zeros(1,D) 1]

h = 1×4

     0     0     0     1

Переключите последовательность путем пропущения его через КИХ h. Отметьте начальные нули в начале выхода, те показывают начальное условие, которое свойственно к таким фильтрам.

x = (1:10)';
dfir = dsp.FIRFilter(h);
y = dfir(x)'

y = 1×10

     0     0     0     1     2     3     4     5     6     7

Задержки нецелого числа через Интерполяцию D/A

Задержка последовательности $\mathit{x}\left[\mathit{n}-\mathit{D}\right]$ не задан каждый раз, когда D не является целым числом. Чтобы сделать такие дробные задержки разумными, нужно добавить промежуточный этап интерполяции D/A, чтобы произвести выход на contniuum. Таким образом, $\mathit{y}\left[\mathit{n}\right]=\widehat{{\mathit{x}}_{\mathit{n}}}\left(\mathit{n}-\mathit{D}\right)$ где $\widehat{{\mathit{x}}_{\mathit{n}}}$ обозначает некоторую интерполяцию D/A входа sequnce $\mathit{x}$. D/A, интерполирующий функцию$\widehat{{\mathit{x}}_{\mathit{n}}}$ мог зависеть от с n и мог считаться представлением базовой модели аналогового сигнала от который последовательность $\mathit{x}$ был произведен. Эта стратегия используется в других проблемах передискретизации, таких как преобразование уровня.

Этот пример покажет дробные фильтры задержки с помощью двух моделей интерполяции, обе из которых предлагаются как часть Системного Тулбокса DSP.

Bandlimited дробные фильтры задержки

Интерполяционная формула Шенноновского Уиттекера $\hat{\mathit{x}}\left(\mathit{t}\right)=\sum _{\mathit{k}}\mathit{x}\left[\mathit{k}\right]\mathrm{sinc}\left(\mathit{t}-\mathit{k}\right)$ модели bandlimited сигналы. Таким образом, промежуточное преобразование D/A $\hat{\mathit{x}}$ bandlimited реконструкция входной последовательности. Для значения задержки D, дробной задержки $\mathit{y}\left[\mathit{n}\right]=\hat{\mathit{x}}\left(\mathit{n}-\mathit{D}\right)$, который использует то же самое $\hat{\mathit{x}}$ для каждого n, может быть представлен как фильтр свертки. Этот фильтр называется идеалом bandlimited дробным фильтром задержки, и его импульсная характеристика

$$h_D[k]=\text{sinc}(k-D)$$.

Соответствующей частотной характеристикой (то есть, DTFT) дают $$H_D(\omega )=e^{-i\omega D}$$.

Причинное КИХ-приближение идеального фильтра сдвига Bandlimited

Идеал sinc фильтр сдвига, описанный в предыдущем разделе, является фильтром все-передачи (i.e. $\left|{\mathit{H}}_{\mathit{d}}\left(\omega \right)\right|=1$), но это имеет бесконечную и непричинную импульсную характеристику ${\mathit{h}}_{\mathit{D}}$. В MATLAB это не может быть представлено как вектор, а скорее в зависимости от индекса k.

% Ideal Filter sequence
D = 0.4;
hIdeal = @(k) sinc(k-D); 

В практических и вычислительных целях идеальный фильтр может быть усеченным на конечном окне индекса по стоимости некоторой потери полосы пропускания. Для целевого значения задержки $\mathit{D}$ и желаемая длина N, окно индексов $\mathit{k}$удовлетворение $|\mathit{D}-\mathit{k}|\le \frac{\mathit{N}}{2}$ симметрично о $\mathit{D}$, и получает основной лепесток идеального фильтра. Для $\mathit{D}={\mathit{i}}_0+\mathit{FD}$ где $\mathit{0}\le \mathit{FD}\le 1$ и целое число ${\mathit{i}}_0$, явные индексы окна$$\{i_0-\lfloor \frac{N-1}{2}\rfloor ,\dots ,i_0+\lfloor \frac{N}{2}\rfloor \}$$. Целое число ${\mathit{i}}_0$ упоминается как целочисленная задержка и может быть выбран произвольно. Чтобы сделать КИХ причинным, установить ${\mathit{i}}_0=\lfloor \frac{\mathit{N}-1}{2}\rfloor$, таким образом, окно индекса $\left\{0,\dots ,\mathit{N}-1\right\}$. Код ниже изображает объяснение позади причинного КИХ-приближения.

% FIR approximation with causal shift
N = 6;
idxWindow = (-floor((N-1)/2):floor(N/2))';
i0 = -idxWindow(1); % Causal latency
hApprox = hIdeal(idxWindow);
plot_causal_fir("sinc",D,N,i0,hApprox,hIdeal);

Усечение фильтра sinc вызывает пульсацию в частотной характеристике, которая может быть обращена путем применения весов $\left\{{\mathit{w}}_{\mathit{k}}\right\}$ (такие как Кайзер или Хэмминг) к КИХ-коэффициентам.

Наконец, получившаяся КИХ-модель приближения идеала bandlimited дробный фильтр задержки приведена ниже.

Можно спроектировать такой фильтр с помощью designFracDelayFIR функционируйте и dsp.VariableFractionalDelay Система object™ в 'FIR' режим, оба из которых используют веса окна Кайзера.

Основанные на Лагранже дробные фильтры задержки

Основанные на Лагранже дробные фильтры задержки используют polynmial, соответствующий на движущемся окне входных выборок. Таким образом, $\widehat{{\mathit{x}}_{\mathit{n}}}\left(\mathit{t}\right)$ полином некоторой фиксированной степени K. Как находящиеся в sinc фильтры задержки, основанные на Лагранже фильтры задержки могут быть сформулированы как причинная КИХ-свертка (i.e. $\mathit{y}=\mathit{h}*\mathit{x}$) из длины N=K+1, и поддерживаемый на окне индекса$$\{-\lfloor \frac{N-1}{2}\rfloor ,\dots \lfloor \frac{N}{2}\rfloor \}$$. Так же к находящейся в sinc модели, примените причинную задержку ${\mathit{i}}_0=\lfloor \frac{\mathit{N}-1}{2}\rfloor$. Учитывая дробную задержку $\mathit{FD}$, КИХ-коэффициенты $\mathit{h}\left[0\right],\dots ,\mathit{h}\left[\mathit{K}\right]$ из (причинный переключенный) Лагранжев фильтр задержки может быть получен путем решения системы линейного equaions, как записано ниже. Те уравнения определяют стандартный Лагранжев многочлен подходящая проблема.

Здесь, ${\mathit{t}}_0,\dots ,{\mathit{t}}_{\mathit{K}}$ перечислимые индексы демонстрационного окна. Реализация является прямой.

% Filter parameters
FD = 0.4;
K = 7;    % Polynomial degree
N = K+1;  % FIR Length
idxWindow = (-floor((N-1)/2):floor(N/2))';

% Define and solve Lagrange interpolation equations
V = idxWindow.^(0:K); % Vandermonde structure
C = FD.^(0:K);

hLagrange = C/V;  % Solve for the coefficients
i0 = -idxWindow(1); % Causal latency
plot_causal_fir("Lagrange",FD,N,i0,hLagrange);

Эта модель может быть реализована как КИХ-фильтр прямой формы, если значение задержки, FD фиксируется, или использование структуры Фэрроу, если значение задержки варьируется. Существует раздел ниже специализированного implementaiton Лагранжевой интерполяции с помощью dsp.VariableFractionalDelay в 'Farrow' режим.

Разработка и реализация находящиеся в sinc Дробные КИХ-Фильтры Задержки

Следующий раздел является особым вниманием при разработке и реализовании находящихся в sinc дробных фильтров задержки.

Функция designFracDelayFIR в режиме проектирования длины

Функциональный designFracDelayFIR обеспечивает простой интерфейс, чтобы спроектировать дробный КИХ-фильтр задержки значения задержки FD и длины N.

FD = 0.32381;
N = 10;
h = designFracDelayFIR(FD,N)

h = 1×10

    0.0046   -0.0221    0.0635   -0.1664    0.8198    0.3926   -0.1314    0.0552   -0.0200    0.0042

Сама реализация может быть сделана как стандартный КИХ-фильтр, такой как dsp.FIRFilter Системный объект.

% Create an FIR filter object
fdfir = dsp.FIRFilter(h); 

Задержите сигнал путем пропущения его через спроектированный фильтр.

% Generate some input
n = (1:100)';
x = gen_input_signal(n);

% Filter the input signal
y = fdfir(x);
plot_sequences(n,x, n,y);
legend('Filter Output','Original Sequence')
title('Raw Filter Output v.s. Input Sequence')

release(fdfir);

Заметьте, что фактическая задержка фильтра не $\mathit{FD}$, а скорее $\mathit{FD}+{\mathit{i}}_0$ из-за причинной целочисленной задержки ${\mathit{i}}_0$. Та задержка возвращена в designFracDelayFIR функция также. Переключите график входной последовательности $\mathit{FD}+{\mathit{i}}_0$ выровнять фильтр выход с ожидаемым результатом.

[h,i0] = designFracDelayFIR(FD,N);
y = fdfir(x);
plot_sequences(n+i0+FD,x, n,y);
legend('Filter Output','Input Sequence (shifted by FD+i0)')
title('Filter Output v.s. Time Adjusted Input Sequence')

Обратите внимание на то, что переключенные входные маркеры, расположенные в $\left(\mathit{n}+\mathit{FD}+{\mathit{i}}_0,\mathit{x}\left[\mathit{n}\right]\right)$ обычно не совпадайте с выходными демонстрационными маркерами $\left(\mathit{n},\mathit{y}\left[\mathit{n}\right]\right)$, потому что $\mathit{n}+\mathit{FD}+{\mathit{i}}_0$ падения на значениях нецелого числа на оси X, тогда как n является целым числом. Скорее переключенные входные выборки падают приблизительно на линию, соединяющую каждые два последовательных выхода выборки.

plot_sequences(n+i0+FD,x, n,y,'with line');
legend('Filter Output','Input Sequence (shifted by FD+i0)')
title('Output Samples v.s. Shifted Input Samples ')
xlim([20,30])

dsp.VariableFractionalDelay Системный объект in 'FIR' Режим

Так же к designFracDelayFIR, dsp.VariableFractionalDelay объект может также спроектировать находящиеся в sinc фильтры задержки, когда используется с 'FIR' режим интерполяции. Начните путем создания экземпляра Системного объекта. КИХ-длина всегда даже и задана как поясной параметр.

vfd_fir = dsp.VariableFractionalDelay('InterpolationMethod','FIR','FilterHalfLength',N/2);
i0_vfd_fir = vfd_fir.FilterHalfLength;    % Interger latency

Передайте желаемую дробную задержку как второй входной параметр к вызову объектов. Убедитесь, что значение задержки, которое вы задаете, включает целочисленную задержку.

y = vfd_fir(x,i0+FD);
release(vfd_fir)
plot_sequences(n+i0+FD,x, n,y);
legend('Filter Output','Input Sequence (shifted by FD+i0)')
title('dsp.VariableFractionalDelay in FIR Mode')

Сравнение designFracDelayFIR и dsp.VariableFractionalDelay в 'КИХ-' Режиме

Оба designFracDelayFIR и dsp.VariableFractionalDelay в 'FIR' режим обеспечивает находящиеся в sinc дробные фильтры задержки, но их реализации отличаются.

Использование designFractionalDelayFIR предпочтен по dsp.VariableFractionalDelay в 'FIR' режим для его простоты, лучшей эффективности и КПД. В рисунке ниже фильтр спроектирован с dsp.VariableFractionalDelay имеет более короткую полосу пропускания, и ее групповая задержка выключена ~0.02 от номинальной стоимости.

% Obtain the FIR coefficients from the dsp.VariableFractionalDelay object
h_vfd_fir = vfd_fir([1;zeros(31,1)],i0_vfd_fir+FD);
release(vfd_fir);
plot_freq_and_gd(h,i0,[],"designFracDelayFIR", h_vfd_fir,i0_vfd_fir,[],"dsp.VariableFractionalDelay FIR mode");
hold on;
yline(FD,'DisplayName','Target Fractional Delay');
ylim([-0.1,0.4])

Разработка и реализация основанные на Лагранже фильтры задержки

Основанный на Лагранже дробный фильтр задержки является в вычислительном отношении дешевым и может быть реализован эффективно с помощью структуры Фэрроу. Фильтр Фэрроу является специальным типом КИХ, который реализован с помощью только элементарные алгебраические операции, такие как скалярные сложения и умножение. В отличие от находящихся в sinc проектов, фильтры Фэрроу не требуют, чтобы специализированные функции (такие как sinc или функция Бесселя) вычислили КИХ-коэффициенты задержки. Это делает Фэрроу, которую дробная задержка фильтрует особенно простой реализовать на базовом оборудовании.

На оборотной стороне основанные на Лагранже фильтры задержки ограничиваются младшими разрядами, из-за очень нестабильного характера знатных полиномиальных приближений. Это обычно заканчивается с более низкой полосой пропускания, при сравнении с находящимся в sinc фильтром.

Системный объект dsp.VariableFractionalDelay в 'Farrow' mode

Используйте системный объект dsp.VariableFractionalDelay в 'Farrow' режим, чтобы создать и реализовать Фэрроу задерживает фильтры. Начните путем создания экземпляра системного объекта:

vfd = dsp.VariableFractionalDelay('InterpolationMethod','Farrow','FilterLength',8);
i0var = floor(vfd.FilterLength/2)  % Interger latency of the filter

i0var = 4

Примените созданный объект на входной сигнал и постройте результат.

y = vfd(x,i0var+FD);
plot_sequences(n+i0var+FD,x, n,y);
legend('Farrow Fractional Delay Output','Input Sequence (shifted by FD+i0)')
title('dsp.VariableFractionalDelay in Farrow Mode')

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

release(vfd)
FDs = i0var+5*(0:0.2:0.8); % Fractional delays vector
xsource = dsp.SignalSource(x,20);
ysink = dsp.AsyncBuffer;
for FD=FDs
    xk = xsource();
    yk = vfd(xk, FD);
    write(ysink,yk);
end
y = read(ysink);

plot_sequences(n+i0var,x, n,y);
legend('Variable Fractional Delay Output','Original Sequence (shifted by i0)')
title('dsp.VariableFractionalDelay in Farrow Mode, Varying Delay')

Полоса пропускания КИХ дробные фильтры задержки: анализ и проектирование

Более длинные фильтры дают лучшее приближение идеального фильтра задержки. Действительно, в терминах необработанных квадратичных норм это имеет место. Однако нам нужна метрика, которая более практически значима, такова как полоса пропускания. Функциональный designFracDelayFIR меры объединили полосу пропускания, которая задана как частотный диапазон, в котором и усиление и групповая задержка в 1% их номинальной стоимости. Измеренная объединенная полоса пропускания может быть получена как возвращаемое значение designFracDelayFIR функция. Сравните фильтр длины 16 (синих) с фильтром длины 256 (красных) в рисунке ниже. Как ожидалось, более длинный фильтр имеют значительно более высокую объединенную полосу пропускания.

FD = 0.3;
N1 = 16;
N2 = 256;
[h1,i1,bw1] = designFracDelayFIR(FD, N1);
[h2,i2,bw2] = designFracDelayFIR(FD, N2);

plot_freq_and_gd(h1,i1,bw1,"N="+num2str(N1), h2,i2,bw2,"N="+num2str(N2));
ylim([-0.2,0.6])

Функция designFracDelayFIR в режиме проектирования полосы пропускания

Режим проектирования полосы пропускания designFracDelayFIR может определить необходимую длину для данной полосы пропускания. Задайте значение задержки и желаемую целевую полосу пропускания как входные параметры к функции, и функция найдет соответствующую длину.

FD = 0.3;
bwLower = 0.9; % Target bandwidth lower limit
[h,i0fixed,bw] = designFracDelayFIR(FD,bwLower);
fdfir = dsp.FIRFilter(h);
info(fdfir)

ans = 6x35 char array
    'Discrete-Time FIR Filter (real)    '
    '-------------------------------    '
    'Filter Structure  : Direct-Form FIR'
    'Filter Length     : 52             '
    'Stable            : Yes            '
    'Linear Phase      : No             '

Обратите внимание на то, что bwLower просто нижняя граница для объединенной полосы пропускания. Функция возвращает фильтр, объединенная полоса пропускания которого является, по крайней мере, значением, заданным в bwLow.

Искажение в высоких сигналах полосы пропускания

В этом разделе мы сравниваем эффективность двух точек проекта (длинный sinc v.s. короткий Лагранж) с высоким входом полосы пропускания. dsp.VariableFractionalDelay в предыдущем разделе структура Фэрроу с 8 степенями, эффективно КИХ длины 9. Фильтр получен designFracDelayFIR(FD,0.9) имеет продолжительность 52 выборок. Соединение двух КИХ-частотных характеристик на том же графике демонстрирует различие в полосе пропускания между двумя.

release(vfd);
hvar = vfd([1;zeros(31,1)],i0var+FD);
plot_freq_and_gd(h,i0fixed,bw,"Sinc-based", hvar,i0var,[],"Farrow");
ylim([-0.2,0.6])

Примените два фильтра на высокий сигнал полосы пропускания, как сравнено в рисунке ниже. Sinc на левом столбце, Фэрроу справа. Временной интервал на верхней строке, частота на нижней части. Результаты, как ожидалось:

n=(1:80)';
x = high_bw_signal(n);

y1 = fdfir(x);
y2 = vfd(x,i0var+FD);

plot_signal_comparison(n,x,y1,y2,h,hvar,i0fixed,i0var,FD);

Который должен использоваться: dsp.VariableFractionalDelay или designFracDelayFIR ?

Это решение в основном основано на требованиях фильтра и целевой платформе.