www.pudn.com > MATLAB.rar > my_conv_fp_2.m, change:2013-03-20,size:5138b


% ------------------------------------------------------------------------- 
% 
%   Archivo:        my_conv_fp_2.m 
% 
%   Descripción:    Convolución de dos Señales en punto Fijo 
% 
%   Parámetros:     h :Señal a convolucionar. 
%                   x: Señal a convolucionar. 
%                   WordLength : Cantidad de bits del ADC simulado 
%                   FractLength : Cantidad de bits de parte fraccionaria 
% 
%   Devuelve:       y_fp: Vector con la señal generada en punto fijo. 
%                   yN: Cantidad de muestras de signal. 
% 
%   Autor:          ROUX, Federico G. (rouxfederico@gmail.com) 
% 
%   Profesor: Ing. BRUNO, Julián S. 
%   RT-DSP, Departamento de Ing.Electrónica. 
%   05/2010 UTN-BA 
% ------------------------------------------------------------------------- 
 
function [y_fp yN] = my_conv_fp_2(h, x, h_WL, h_FL, x_WL, x_FL) 
 
ModoOverFlow='Wrap';                                                    % Modo de saturación Wrap-around 
%ModoOverFlow='Saturate';                                               % Modo de saturación "Saturate" 
 
hN = size(h, 2);                                                        % Calculo el largo de h 
xN = size(x, 2);                                                        % Calculo el largo de x 
 
yN = hN + xN - 1;                                                       % Cantidad final de muestras del array de salida 
y = zeros(1, yN);                                                       % Inicializo con cero muestras 
 
bloque_z = zeros(1, hN - 1);                                            % Genero un vector de ceros a agregar a la señal 
x_conv(1, :) = [bloque_z x bloque_z];                                   % Agrego ceros para multiplicar por cero hasta la entrada completa de h[n] en x[n] 
 
%% Definición y cuantificación en el sistema numérico del DSP BF533: 
 
q_x = quantizer('Mode', 'fixed',...                                      % Creo un objeto cuantizador 1.15 
                'Format', [WordLength FractLength],... 
                'OverflowMode', ModoOverFlow,...  
                'RoundMode', 'floor');                                                          
                                                                        % Cuantifico las señales a 1.15(el tipo de datos que usa sigue siendo double) 
x_q = quantize(q, x_conv);                                              % Señal cuantizada  
h_q = quantize(q, h);                                                   % Kernel cuantizado 
y_q = quantize(q, y);                                                   % Salida cuantizada->son todos ceros a esta altura 
 
% Definimos el tipo numerico 1.15, que es el tipo que usan los operandos de la ALU 
T = numerictype(    'Signed', true, ... 
                    'WordLength', WordLength, ... 
                    'FractionLength', FractLength); 
 
% Definimos el tipo numerico 9.31, que es el tipo en el que se acumulan los datos 
T_MAC = numerictype('Signed', true, ... 
                    'WordLength', 40, ... 
                    'FractionLength', 31); 
 
% Definimos la aritmética de la MAC 
F_MAC = fimath( 'ProductMode', 'SpecifyPrecision', ... 
                'ProductWordLength', 32, ... 
                'ProductFractionLength', 31, ... 
                'SumMode', 'SpecifyPrecision', ... 
                'SumWordLength', 40, ... 
                'SumFractionLength', 31, ... 
                'OverFlowMode', ModoOverFlow,... 
                'RoundMode', 'floor'); 
 
producto_fp = fi( 0 , T , F_MAC);                                       % Genero la variable para almacenar el producto 
     
Acum     = fi(0 , T_MAC , F_MAC );                                      % Genero el acumulador principal 
Acum_aux = fi(0 , T_MAC , F_MAC );                                      % Genero el acumulador auxiliar 
         
         
% A partir de las señales cuantizadas, genero señales FI 
x_fp = fi(x_q, T, F_MAC );                                              % Señal en punto fijo 
h_fp = fi(h_q, T, F_MAC );                                              % Kernel en punto fijo 
y_fp = fi(y_q, T, F_MAC );                                              % Salida en punto fijo 
 
 
%% Algoritmo de convolución en Punto Fijo         
         
for i = 1:yN 
     
    y_fp(i) = 0;                                    % inicializo el elemento i 
     
    Acum = 0;                                       % Inicializo el acumulador en cero 
     
    for j = 1:hN 
         
        ind_y = i;                                  % indice del array a guardar 
        ind_h = hN - (j - 1);                       % indice de la señal que convoluciona: cuenta hacia atrás igual en todas las iteraciones. 
        ind_x = (i - 1) + j;                        % indice de la señal a convolucinar: cuenta hacia adelante desplazada (i-1) veces 
         
        producto_fp = h_fp(ind_h) * x_fp(ind_x);    % Producto 
        Acum = Acum + producto_fp;                  % Guardo en el acumulador 
     
    end 
     
    y_fp(i)=Acum;                                   % Guardo el resultado en la señal de salida 
end 
 
 
end