FIR-фильтр (Finite Impulse Response) — это фильтр с конечной импульсной характеристикой, также известный как нерекурсивный фильтр.

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

Принцип FIR-фильтра

КИХ-фильтр — это фильтр с импульсной характеристикой конечной длины. Структура прямой формы выглядит следующим образом:

КИХ-фильтр по существу представляет собой свёртку входного сигнала с функцией единичной импульсной характеристики, что выражается следующим образом:

КИХ-фильтр обладает следующими характеристиками:

  • (1) Отклик представляет собой последовательность конечной длины.
  • (2) Системная функция сходится при |z| > 0, все полюсы расположены в z=0, и система является причинной.
  • (3) По структуре он нерекурсивный, без обратной связи с выхода на вход.
  • (4) Фазовый отклик входного сигнала линеен, поскольку коэффициенты функции отклика h(n) симметричны.
  • (5) Относительные разности фаз между частотными составляющими входного сигнала также фиксированы.
  • (6) Свёртка во временной области равна умножению в частотной области, поэтому эта свёртка эквивалентна коэффициенту усиления для фильтрации каждой частотной составляющей в спектре. Некоторые частотные составляющие сохраняются, а другие ослабляются, тем самым достигается эффект фильтрации.

Проектирование параллельного КИХ-фильтра

Описание проекта

Входной сигнал представляет собой смешанный синусоидальный сигнал с частотами 7.5 MHz и 250 KHz. После прохождения через КИХ-фильтр высокочастотный сигнал 7.5 MHz удаляется, и сохраняется только сигнал 250 KHz. Параметры проектирования следующие:

输入频率:    7.5MHz 和 250KHz
采样频率:    50MHz
阻带:           1MHz ~ 6MHz
阶数:           15(N-1=15)

Из структуры КИХ-фильтра следует, что при порядке 15 реализация требует 16 умножителей, 15 сумматоров и 15 наборов регистров задержки. Чтобы стабилизировать данные первого такта, можно использовать ещё один набор регистров задержки, поэтому всего используется 16 наборов регистров задержки. Благодаря симметрии коэффициентов КИХ-фильтра количество умножителей можно уменьшить вдвое, используя всего 8 умножителей.

Параллельная реализация означает одновременное выполнение умножения и сложения для 16 задержанных элементов данных в течение одного такта, а затем вывод отфильтрованного значения под управлением тактового сигнала. Преимущество этого метода — малая задержка фильтрации, но предъявляются довольно высокие требования к временным характеристикам.

Параллельная реализация

Для кода модуля умножителя, используемого в данной реализации, обратитесь к умножителю из предыдущей конвейерной реализации.

Для удобства быстрого моделирования можно также напрямую использовать знак умножения*для выполнения операции умножения. В реализацию добавлено макроопределение SAFE_DESIGN для выбора используемого умножителя.

Коэффициенты КИХ-фильтра можно сгенерировать с помощью matlab; подробности см. в приложении.

Пример

/***********************************************************
>> V201001 : Fs:50Mhz, fstop:1Mhz-6Mhz, order: 15
************************************************************/

`define SAFE_DESIGN
 
module fir_guide    (
    input                rstn,  // Сброс, активный низкий уровень
    input                clk,   // Рабочая частота, то есть частота дискретизации
    input                en,    // Сигнал валидности входных данных
    input        [11:0]  xin,   // Входные данные сигнала со смешанными частотами
    output               valid, // Сигнал валидности выходных данных
    output       [28:0]  yout   // Выходные данные, низкочастотный сигнал, т. е. 250KHz
    );
 
    //задержка разрешения данных
    reg [3:0]            en_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            en_r[3:0]      <= 'b0 ;
        end
        else begin
            en_r[3:0]      <= {en_r[2:0], en} ;
        end
    end
 
   //(1) 16 наборов сдвиговых регистров
    reg        [11:0]    xin_reg[15:0];
    reg [3:0]            i, j ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            for (i=0; i<15; i=i+1) begin
                xin_reg[i]  <= 12'b0;
            end
        end
        else if (en) begin
            xin_reg[0] <= xin ;
            for (j=0; j<15; j=j+1) begin
                xin_reg[j+1] <= xin_reg[j] ; // Периодическая операция сдвига
            end
        end
    end
 
   //Требуется только 8 умножителей из-за симметрии коэффициентов FIR-фильтра
   //(2) Коэффициенты симметричны; сложите первые и последние данные из 16 сдвиговых регистров
    reg        [12:0]    add_reg[7:0];
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            for (i=0; i<8; i=i+1) begin
                add_reg[i] <= 13'd0 ;
            end
        end
        else if (en_r[0]) begin
            for (i=0; i<8; i=i+1) begin
                add_reg[i] <= xin_reg[i] + xin_reg[15-i] ;
            end
        end
    end
 
    //(3) 8 умножителей
    // Коэффициенты фильтра, уже усиленные на определённый коэффициент
    wire        [11:0]   coe[7:0] ;
    assign coe[0]        = 12'd11 ;
    assign coe[1]        = 12'd31 ;
    assign coe[2]        = 12'd63 ;
    assign coe[3]        = 12'd104 ;
    assign coe[4]        = 12'd152 ;
    assign coe[5]        = 12'd198 ;
    assign coe[6]        = 12'd235 ;
    assign coe[7]        = 12'd255 ;
    reg        [24:0]   mout[7:0];
 
`ifdef SAFE_DESIGN
    // Конвейерный умножитель
    wire [7:0]          valid_mult ;
    genvar              k ;
    generate
        for (k=0; k<8; k=k+1) begin
            mult_man #(13, 12)
            u_mult_paral          (
              .clk        (clk),
              .rstn       (rstn),
              .data_rdy   (en_r[1]),
              .mult1      (add_reg[k]),
              .mult2      (coe[k]),
              .res_rdy    (valid_mult[k]), // Все разрешения выходов в точности одинаковы
              .res        (mout[k])
            );
        end
    endgenerate
    wire valid_mult7     = valid_mult[7] ;
 
`else
    // Если требования к таймингу не строгие, можно напрямую использовать знак умножения
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            for (i=0 ; i<8; i=i+1) begin
                mout[i]     <= 25'b0 ;
            end
        end
        else if (en_r[1]) begin
            for (i=0 ; i<8; i=i+1) begin
                mout[i]     <= coe[i] * add_reg[i] ;
            end
        end
    end
    wire valid_mult7 = en_r[2];
`endif
 
    //(4) Накопление, 8 групп 25-битных данных -> 1 группа 29-битных данных
    // Задержка валидности данных
    reg [3:0]            valid_mult_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            valid_mult_r[3:0]  <= 'b0 ;
        end
        else begin
            valid_mult_r[3:0]  <= {valid_mult_r[2:0], valid_mult7} ;
        end
    end

`ifdef SAFE_DESIGN
    // Во время сложения конвейеризировать на несколько тактов для оптимизации тайминга
    reg        [28:0]    sum1 ;
    reg        [28:0]    sum2 ;
    reg        [28:0]    yout_t ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            sum1   <= 29'd0 ;
            sum2   <= 29'd0 ;
            yout_t <= 29'd0 ;
        end
        else if(valid_mult7) begin
            sum1   <= mout[0] + mout[1] + mout[2] + mout[3] ;
            sum2   <= mout[4] + mout[5] + mout[6] + mout[7] ;
            yout_t <= sum1 + sum2 ;
        end
    end
 
`else
    // Вычислить результат накопления за один шаг, но на практике такая синхронизация очень опасна
    reg signed [28:0]    sum ;
    reg signed [28:0]    yout_t ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            sum    <= 29'd0 ;
            yout_t <= 29'd0 ;
        end
        else if (valid_mult7) begin
            sum    <= mout[0] + mout[1] + mout[2] + mout[3] + mout[4] + mout[5] + mout[6] + mout[7];
            yout_t <= sum ;
        end
    end
`endif
    assign yout  = yout_t ;
    assign valid = valid_mult_r[0];

endmodule

testbench

Тестовый стенд написан следующим образом. Его основная функция — непрерывно, без прерываний, подавать входные данные смешанного сигнала синусоидальных волн 250KHz и 7.5MHz. Входные данные смешанного сигнала также можно сгенерировать с помощью matlab; подробности см. в приложении.

Пример

`timescale 1ps/1ps
 
module test ;
   //вход
    reg          clk ;
    reg          rst_n ;
    reg          en ;
    reg [11:0]   xin ;
    //выход
    wire         valid ;
    wire [28:0]  yout ;
 
    parameter    SIMU_CYCLE   = 64'd2000 ;  // 50MHz частота дискретизации
    parameter    SIN_DATA_NUM = 200 ;      // Период моделирования

//=====================================
// Генерация 50MHz clk
    localparam   TCLK_HALF     = 10_000;
    initial begin
        clk = 1'b0 ;
        forever begin
            # TCLK_HALF ;
            clk = ~clk ;
        end
    end
 
//============================
// сброс и завершение
    initial begin
        rst_n = 1'b0 ;
        # 30   rst_n = 1'b1 ;
        # (TCLK_HALF * 2 * SIMU_CYCLE) ;
        $finish ;
    end
 
//=======================================
// считать данные сигнала в регистр
    reg          [11:0] stimulus [0: SIN_DATA_NUM-1] ;
    целое число      i ;
    initial begin
        $readmemh("../tb/cosx0p25m7p5m12bit.txt", stimulus) ;
        i = 0 ;
        en = 0 ;
        xin = 0 ;
        # 200 ;
        forever begin
            @(negedge clk) begin
                en          = 1'b1 ;
                xin         = stimulus[i] ;
                if (i == SIN_DATA_NUM-1) begin  // Периодическая подача данных управления
                    i = 0 ;
                end
                else begin
                    i = i + 1 ;
                end
            end
        end
    end
 
    fir_guide u_fir_paral (
      .xin         (xin),
      .clk         (clk),
      .en          (en),
      .rstn        (rst_n),
      .valid       (valid),
      .yout        (yout));
 
endmodule

Результаты моделирования

Из результатов моделирования на рисунке ниже видно, что сигнал после FIR-фильтра содержит только один низкочастотный сигнал (250KHz), а высокочастотный сигнал (7.5MHz) отфильтрован. Более того, выходная форма сигнала непрерывна и может выводиться непрерывно.

Однако, как показано в красном круге, начало формы сигнала нерегулярно. Увеличьте эту часть.

После увеличения начала формы сигнала, как показано на рисунке ниже, видно, что период времени нерегулярной формы сигнала, т.е. интервал времени между двумя вертикальными линиями, составляет 16 тактовых циклов.

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

Приложение: использование matlab

Генерация коэффициентов FIR-фильтра

Откройте matlab и введите в командном окне команду: fdatool.

Затем откроется следующее окно; задайте параметры в соответствии с FIR-фильтром.

Выбранный здесь метод реализации FIR — метод наименьших квадратов (Least-squares). Разные методы реализации дают разные эффекты фильтрации.

Нажмите File -> Export

Экспортируйте параметры фильтра и сохраните их в переменной coef, как показано на рисунке ниже.

На этом этапе переменная coef должна содержать данные с плавающей запятой. Умножьте её на определённый коэффициент для расширения, а затем возьмите её приближённые данные с фиксированной запятой в качестве параметров FIR-фильтра в проекте. Здесь коэффициент расширения равен 2048, результаты следующие.

Генерация входного смешанного сигнала

Эталонный код для генерации смешанного входного сигнала с помощью matlab выглядит следующим образом.

Сигнал представляет собой беззнаковые данные с фиксированной запятой с разрядностью 12 бит, сохранённые в файлеcosx0p25m7p5m12bit.txt。

Пример

clear all;close all;clc;
%=======================================================
% генерация данных cos-волны в формате txt hex
%=======================================================

fc          = 0.25e6 ;      %Центральная частота
fn          = 7.5e6 ;       %Частота помех
Fs          = 50e6 ;        %Частота дискретизации
T           = 1/fc ;        %Период сигнала
Num         = Fs * T ;      %Число точек дискретизации сигнала в одном периоде
t           = (0:Num-1)/Fs ;      %Дискретное время
cosx        = cos(2*pi*fc*t) ;    %Синусоидальный сигнал центральной частоты
cosn        = cos(2*pi*fn*t) ;    %Сигнал помех
cosy        = mapminmax(cosx + cosn) ;     %Амплитуда расширена до диапазона (-1,1)
cosy_dig    = floor((2^11-1) * cosy + 2^11) ;     %Амплитуда расширена до0~4095
fid         = fopen('cosx0p25m7p5m12bit.txt', 'wt') ;  %Записать файл данных
fprintf(fid, '%x\n', cosy_dig) ;
fclose(fid) ;
 
%Сигнал во временной области
figure(1);
subplot(121);plot(t,cosx);hold on ;
plot(t,cosn) ;
subplot(122);plot(t,cosy_dig) ;
 
%Сигнал в частотной области
fft_cosy    = fftshift(fft(cosy, Num)) ;
f_axis      = (-Num/2 : Num/2 - 1) * (Fs/Num) ;
figure(5) ;
plot(f_axis, abs(fft_cosy)) ;

Скачать исходный код

Скачать