Diseño de filtro FIR serial

Descripción del diseño

Los parámetros de diseño no cambian, son consistentes con los parámetros del filtro FIR paralelo. Es decir, la señal mixta de ondas sinusoidales de 7.5 MHz y 250 KHz de frecuencia de entrada, después de pasar por el filtro FIR, la señal de alta frecuencia de 7.5 MHz se elimina, conservando solo la señal de 250 KHz.

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

El diseño serial consiste en realizar operaciones de multiplicación y suma en secuencia para los 16 datos retardados dentro de 16 ciclos de reloj, y luego generar el valor filtrado impulsado por el reloj. Teniendo en cuenta la simetría de los coeficientes del filtro FIR, el ciclo para calcular un valor de salida filtrado puede reducirse a 8. En el diseño serial, solo se realiza una operación de multiplicación por ciclo, por lo que solo se necesita un multiplicador en el diseño. En este momento, los datos deben ingresarse de manera válida cada 8 ciclos de reloj, pero para garantizar la corrección de la frecuencia de la señal de salida, el reloj de trabajo debe ser 8 veces la frecuencia de muestreo, es decir, 400 MHz. La ventaja de este método es que consume menos recursos, pero requiere una frecuencia de trabajo alta y los datos no pueden emitirse de forma continua.

Diseño serial

El código del módulo multiplicador utilizado en el diseño puede hacer referencia al multiplicador de diseño de pipeline anterior.

Para facilitar una simulación rápida, también se puede usar directamente el signo de multiplicación*para completar la operación de multiplicación. En el diseño se añade la definición de macro SAFE_DESIGN para seleccionar qué tipo de multiplicador usar.

Los coeficientes del filtro FIR pueden generarse con matlab; consulte el apéndice para más detalles.

Ejemplo

/**********************************************************
>> Description : fir study with serial tech
>> V190403     : Fs:50Mhz, fstop:1-6Mhz, order:16, sys clk:400MHz
***********************************************************/

`define SAFE_DESIGN
 
module fir_serial_low(
    input                rstn,
    input                clk,   // Reloj de trabajo del sistema, 400MHz
    input                en ,   // Señal válida de datos de entrada
    input        [11:0]  xin,   // Datos de señal de frecuencia mixta de entrada
    output               valid, // Señal válida de datos de salida
    output       [28:0]  yout   // Datos de salida
    );
 
   //delay of input data enable
    reg [11:0]            en_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            en_r[11:0]      <= 'b0 ;
        end
        else begin
            en_r[11:0]      <= {en_r[10:0], en} ;
        end
    end
 
    //fir coeficient
    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 ;
 
    //(1) Parte de desplazamiento de datos de entrada
    reg [2:0]            cnt ;
    integer              i, j ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt <= 3'b0 ;
        end
        else if (en || cnt != 0) begin
            cnt <= cnt + 1'b1 ;    // Conteo de 8 ciclos
        end
    end
 
    reg [11:0]           xin_reg[15:0];
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            for (i=0; i<16; i=i+1) begin
                xin_reg[i]  <= 12'b0;
            end
        end
        else if (cnt == 3'd0 && en) begin    // Leer datos válidos una vez cada 8 ciclos
            xin_reg[0] <= xin ;
            for (j=0; j<15; j=j+1) begin
                xin_reg[j+1] <= xin_reg[j] ; // Desplazamiento de datos
            end
        end
    end
 
    //(2) Coeficientes simétricos, los 16 datos del registro de desplazamiento se suman de extremo a extremo
    reg  [11:0]          add_a, add_b ;
    reg  [11:0]          coe_s ;
    wire [12:0]          add_s ;
    wire [2:0]           xin_index = cnt>=1 ? cnt-1 : 3'd7 ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            add_a  <= 13'b0 ;
            add_b  <= 13'b0 ;
            coe_s  <= 12'b0 ;
        end
        else if (en_r[xin_index]) begin //from en_r[1]
            add_a  <= xin_reg[xin_index] ;
            add_b  <= xin_reg[15-xin_index] ;
            coe_s  <= coe[xin_index] ;
        end
    end
    assign add_s = {add_a} + {add_b} ;  
 
    //(3) Operación de multiplicación, usando solo una multiplicación
    reg        [24:0]    mout ;
`ifdef SAFE_DESIGN
    wire                 en_mult ;
    wire [3:0]           index_mult = cnt>=2 ? cnt-1 : 4'd7 + cnt[0] ;
    mult_man #(13, 12)   u_mult_single    // Instanciar el multiplicador de pipeline diseñado por uno mismo
        (.clk        (clk),
         .rstn       (rstn),
         .data_rdy   (en_r[index_mult]),  // Prestar atención a la correspondencia de temporización de los datos
         .mult1      (add_s),
         .mult2      (coe_s),
         .res_rdy    (en_mult),  
         .res        (mout)
        );
 
`else
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            mout   <= 25'b0 ;
        end
        else if (|en_r[8:1]) begin
            mout   <= coe_s * add_s ;  // Multiplicación directa
        end
    end
    wire                 en_mult = en_r[2];
`endif
 
    //(4) Acumulación e integración, 8 grupos de datos de 25 bits -> 1 grupo de datos de 29 bits
    reg        [28:0]    sum ;
    reg                  valid_r ;
    //mult output en counter
    reg [4:0]            cnt_acc_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt_acc_r <= 'b0 ;
        end
        else if (cnt_acc_r == 5'd7) begin  // Temporizar 8 ciclos
            cnt_acc_r <= 'b0 ;
        end
        else if (en_mult || cnt_acc_r != 0) begin // Mientras en esté activo, el temporizador no se detiene
            cnt_acc_r <= cnt_acc_r + 1'b1 ;
        end
    end
 
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            sum      <= 29'd0 ;
            valid_r  <= 1'b0 ;
        end
        else if (cnt_acc_r == 5'd7) begin // En el octavo ciclo de acumulación, generar el valor filtrado
            sum      <= sum + mout;
            valid_r  <= 1'b1 ;
        end
        else if (en_mult && cnt_acc_r == 0) begin // Inicialización
            sum      <= mout ;
            valid_r  <= 1'b0 ;
        end
        else if (cnt_acc_r != 0) begin //acculating between cycles
            sum      <= sum + mout ;
            valid_r  <= 1'b0 ;
        end
    end
 
    // El reloj captura los datos de salida válidos para que la señal de salida no cambie con tanta frecuencia
    reg [28:0]           yout_r ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            yout_r <= 'b0 ;
        end
        else if (valid_r) begin
            yout_r <= sum ;
        end
    end
    assign yout = yout_r ;
 
    //(5) Retardo de validez de los datos de salida, es decir, descartar los primeros 15 valores filtrados
    reg [4:0]    cnt_valid ;
    always @(posedge clk or negedge rstn) begin
        if (!rstn) begin
            cnt_valid      <= 'b0 ;
        end
        else if (valid_r && cnt_valid != 5'd16) begin
            cnt_valid      <= cnt_valid + 1'b1 ;
        end
    end
    assign valid = (cnt_valid == 5'd16) & valid_r ;

endmodule

testbench

El testbench se escribe de la siguiente manera; su función principal es ingresar de forma continua e ininterrumpida los datos de la señal mixta de ondas sinusoidales de 250KHz y 7.5MHz. Los datos de la señal mixta de entrada también pueden generarse con matlab; consulte el apéndice para más detalles.

Entre ellos, la frecuencia de trabajo es de 400MHz, pero los datos de entrada y la señal válida de datos de entrada deben mantenerse ingresando a una frecuencia de 50MHz.

Ejemplo

module test ;
    //input
    reg          clk ;
    reg          rst_n ;
    reg          en ;
    reg  [11:0]  xin ;
    //output
    wire [28:0]  yout ;
    wire         valid ;

    parameter    SIMU_CYCLE   = 64'd1000 ;
    parameter    SIN_DATA_NUM = 200 ;

//=====================================
// 8*50MHz clk generating
    localparam   TCLK_HALF     = (10_000 >>3);
    initial begin
        clk = 1'b0 ;
        forever begin
            # TCLK_HALF clk = ~clk ;
        end
     end
 
//============================
//  reset and finish
    initial begin
        rst_n = 1'b0 ;
        # 30        rst_n = 1'b1 ;
        # (TCLK_HALF * 2 * 8  * SIMU_CYCLE) ;
        $finish ;
    end
 
//=======================================
// read cos data into register
    reg          [11:0] stimulus [0: SIN_DATA_NUM-1] ;
    integer      i ;
    initial begin
        $readmemh("../tb/cosx0p25m7p5m12bit.txt", stimulus) ;
        en = 0 ;
        i = 0 ;
        xin = 0 ;
        # 200 ;
        forever begin
            repeat(7)  @(negedge clk) ; // Dejar vacíos 7 ciclos y proporcionar datos en el octavo ciclo
            en          = 1 ;
            xin         = stimulus[i] ;
            @(negedge clk) ;
            en          = 0 ;         // La señal válida de datos de entrada solo necesita durar un ciclo
            if (i == SIN_DATA_NUM-1)  i = 0 ;
            else  i = i + 1 ;
        end
    end
 
    fir_serial_low       u_fir_serial (
        .clk         (clk),
        .rstn        (rst_n),
        .en          (en),
        .xin         (xin),
        .valid       (valid),
        .yout        (yout));

endmodule

Resultados de la simulación

Según los resultados de simulación en la siguiente figura, la señal después del filtro FIR solo tiene una señal de baja frecuencia (250KHz), y la señal de alta frecuencia (7.5MHz) se ha eliminado. Para que la forma de onda sea más estética, se toman los datos filtrados a partir del decimosexto como salida válida.

La forma de onda ampliada localmente se muestra en la siguiente figura. En este momento, la señal válida de datos de entrada en y la señal válida de datos de salida valid son señales de pulso con el mismo período (50MHz), no son válidas de forma continua. Pero como el reloj de trabajo es de 400MHz, la salida también se presentará como una señal sinusoidal de 250KHz a una frecuencia de muestreo de 50MHz.

Apéndice: uso de matlab (consistente con«Diseño de filtro FIR paralelo»)

Generar los coeficientes del filtro FIR

Abra matlab y en la ventana de comandos ingrese el comando: fdatool.

Luego se abrirá la siguiente ventana; configúrela según los parámetros del filtro FIR, como se muestra a continuación.

El método de implementación de FIR elegido aquí es el de mínimos cuadrados (Least-squares); diferentes métodos de implementación producen diferentes efectos de filtrado.

Haga clic en File -> Export

Exporte los parámetros del filtro y guárdelos en la variable coef, como se muestra en la siguiente figura.

En este momento, la variable coef debería ser datos de tipo flotante. Multiplíquela por un cierto factor de ampliación y luego tome los datos de punto fijo aproximados como parámetros del filtro FIR en el diseño. Aquí se toma el factor de ampliación de 2048, y el resultado se muestra a continuación.

Generar la señal mixta de entrada

El código de referencia para generar la señal mixta de entrada con matlab es el siguiente.

La señal es datos de punto fijo sin signo, con ancho de bits de 12 bits, almacenados en el archivocosx0p25m7p5m12bit.txt 。

Ejemplo

clear all;close all;clc;
%=======================================================
% generating a cos wave data with txt hex format
%=======================================================

fc          = 0.25e6 ;      %Frecuencia central
fn          = 7.5e6 ;       %Frecuencia de la señal de interferencia
Fs          = 50e6 ;        %Frecuencia de muestreo
T           = 1/fc ;        %Período de la señal
Num         = Fs * T ;      %Número de puntos de muestreo de la señal dentro del período
t           = (0:Num-1)/Fs ;      %Tiempo discreto
cosx        = cos(2*pi*fc*t) ;    %Señal sinusoidal de frecuencia central
cosn        = cos(2*pi*fn*t) ;    %Señal de interferencia
cosy        = mapminmax(cosx + cosn) ;     %Amplitud expandida a (-1,1) entre
cosy_dig    = floor((2^11-1) * cosy + 2^11) ;     %Amplitud expandida a0~4095
fid         = fopen('cosx0p25m7p5m12bit.txt', 'wt') ;  %Escribir archivo de datos
fprintf(fid, '%x\n', cosy_dig) ;
fclose(fid) ;
 
%Forma de onda en el dominio del tiempo
figure(1);
subplot(121);plot(t,cosx);hold on ;
plot(t,cosn) ;
subplot(122);plot(t,cosy_dig) ;
 
%Forma de onda en el dominio de la frecuencia
fft_cosy    = fftshift(fft(cosy, Num)) ;
f_axis      = (-Num/2 : Num/2 - 1) * (Fs/Num) ;
figure(5) ;
plot(f_axis, abs(fft_cosy)) ;

Descarga de código fuente

Download