implementazione filtro fir utilizzando cicli for

[alfo84]

Salve a tutti, dopo aver implementato in maniera abbastanza soddisfacente un filtro fir (vedi topic implementazione filtro fir) mi sono cimentato in un'implementazione in cui ho voluto utilizzare i cicli for. Vi posto in allegato il codice che purtroppo mi dà il seguente errore:

"Info: Running Quartus II 64-Bit Analysis & Synthesis
Info: Version 13.0.1 Build 232 06/12/2013 Service Pack 1 SJ Web Edition
Info: Processing started: Fri Sep 13 20:08:05 2013
Info: Command: quartus_map --read_settings_files=on --write_settings_files=off filtro_FIR -c filtro_FIR
Info (11104): Parallel Compilation has detected 8 hyper-threaded processors. However, the extra hyper-threaded processors will not be used by default. Parallel Compilation will use 4 of the 4 physical processors detected instead.
Info (12021): Found 2 design units, including 1 entities, in source file filtro_fir.vhd
Info (12022): Found design unit 1: filtro_FIR-filtro_FIR
Info (12023): Found entity 1: filtro_FIR
Info (12021): Found 2 design units, including 1 entities, in source file reg.vhd
Info (12022): Found design unit 1: reg-reg
Info (12023): Found entity 1: reg
Error (10381): VHDL Type Mismatch error at filtro_FIR.vhd(81): indexed name returns a value whose type does not match "SIGNED", the type of the target expression
Error: Quartus II 64-Bit Analysis & Synthesis was unsuccessful. 1 error, 0 warnings
Error: Peak virtual memory: 500 megabytes
Error: Processing ended: Fri Sep 13 20:08:06 2013
Error: Elapsed time: 00:00:01
Error: Total CPU time (on all processors): 00:00:01"

Code: Select all

--------------- Realizzazione di un filtro FIR ---------------
-- Librerie --
library IEEE;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_signed.all;
-------------------------------------------------------------------------
-- Entità --
entity filtro_FIR is
      generic(
                    num_bit  : integer :=3;
                    num_taps : integer :=4
              );
               
               port(

                    clk        : in  std_logic;
                    reset      : in  std_logic;
                    data_in    : in  signed(num_bit-1 downto 0);          -- ingresso e uscita del blocco fir
                   
                    data_out   : buffer signed(num_bit-1 downto 0)        -- sullo stesso numero di bit
                                                                         
                  );

-- struttura type --   
   type T_coeff  is array (0 to num_taps-1) of integer;
   
   type T_delay  is array (0 to num_taps-1) of signed(num_bit-1 downto 0);      
   type T_t      is array (0 to num_taps-1) of signed(2*num_bit-1 downto 0);
 
end filtro_FIR;
---------------------------------------------------------------------------
-- Architettura --
architecture filtro_FIR of filtro_FIR is

component reg
    port(
   
                    reg_clk    : in std_logic;
                    reg_reset  : in std_logic;
                    D          : in  signed(num_bit-1 downto 0);
                   
                    Q          : out signed(num_bit-1 downto 0)
                   
        );
end component;

  constant coeff : T_coeff := (12, 3, 1, 5);
 
  signal delay : T_delay(0 to num_taps-1);
  signal t     : T_t(0 to num_taps-1);
  signal f     : T_delay(0 to num_taps-1);


begin

  delay(0) <= data_in;
 
 
  ciclo0  : for k in 0 to num_taps-1 generate
 
    Ndelay : reg port map (clk, reset, delay(k),delay(k+1)); 
 
  end generate;
 
   
  ciclo1  : for k in 0 to num_taps-1 generate
 
    Nprod_parziale : t(k) <= delay(k) * conv_signed(coeff(k),num_bit);     
 
  end generate;
 
 
   
  ciclo2  : for i in 0 to num_taps-1 generate
 
    Nprod_fin : f(i) <= t(num_bit-1 downto 0);       ----->  il problema è qua dovrebbe essere t(k) però a me serve anche ridurre
                                                                    ------  il numero di bit scrivendo num_bit -1 downto. Come posso risolvere tale           
                                                                   ------- problema ????
  end generate;   
   
 
   
     data_out <= (others => '0');
    
 ciclo3  : for k in 0 to num_taps-1 generate
 
    Nout : data_out <= data_out + f(k);     
 
 end generate;   

end filtro_FIR;
---------------------------------------------------------------

[alfo84]

Come potrei risolvere il problema?

[Leonardo]

Il codice inizia a diventare complesso e può necessitare di diverso tempo per trovare la soluzione, ti consiglio di isolare meglio l'errore e provare a risolverlo individualmente, definendo molteplici tipi si creano spesso le prime volte problemi di questo tipo.

Tienici aggiornati se riesci a risolvere
Ciao

[alfo84]

Ok, grazie cmq del consiglio. Cercherò di testare un passo alla volta

[alfo84]

Ciao a tutti, dopo un pò di tempo sono riuscito finalmente ad implementare un filtro fir utilizzando dei cicli for. Non mi dà nessun errore e nessun warning. Ora mi sto dedicando alla simulazione e alla realizzazione del testbench. Cmq allego il codice scritto:

[code]-------------------------------- Realizzazione del filtro FIR1 --------------------------------

-- Librerie --

library IEEE;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

-----------------------------------------------------------------------------------------------

-- Entità --

entity filtro_FIR1 is
generic (
num_bit : integer :=16; -- ho messo 16 bit e non 10 altrimenti il coeff 9914
num_taps : integer :=4 -- non posso rappresentarlo con solo 10 bit!!!
);

port(
clock_FIR1 : in std_logic;
reset_FIR1 : in std_logic;
enable_FIR1 : in std_logic;
data_in_FIR1 : in signed(num_bit-1 downto 0);

data_out_FIR1 : buffer signed(num_bit-1 downto 0) -- uscita del filtro fir sullo stesso -- numero di bit dell'ingresso
); -- numero di bit

end filtro_FIR1;

-----------------------------------------------------------------------------------------------

-- Architettura --

architecture filtro_FIR1 of filtro_FIR1 is

component Reg_N
port(
clk : in std_logic;
res : in std_logic;
en : in std_logic;
d : in signed(num_bit-1 downto 0);

q : out signed(num_bit-1 downto 0)
);
end component;

component moltiplicatore_parity_bit
port(
m1 : in signed(num_bit-1 downto 0);
m2 : in signed(num_bit-1 downto 0);
out_parity : out signed(num_bit-1 downto 0)
);
end component;


-- definiamo due nuovi tipi --

type matrix is array(0 to num_taps) of signed(num_bit-1 downto 0); -- num_taps e non nun_taps-1 altrimenti dà errore
type T_coeff is array (0 to num_taps-1) of integer;



constant coeff_2 : T_coeff := (991, -807, -807, 991);

-- "0000001111011111" ricorda coeff_2_1 = 0.09914 (moltiplico per 1000)
-- "1111110011011001" ricorda coeff_2_0 = -0.08071 (moltiplico per 1000)


signal d_FIR1 : matrix; -- campioni
signal t_FIR1 : matrix; -- risultato moltiplicazione a parità di bit
signal COEF_2 : matrix; -- coefficienti c_2

begin

d_FIR1(0) <= data_in_FIR1;

ciclo_Reg_N: for i in 0 to num_taps-1 generate
blocco_ritardo_elementare: Reg_N
port map(clock_FIR1,reset_FIR1,enable_FIR1,d_FIR1(i),d_FIR1(i+1));
end generate ciclo_Reg_N;

ciclo_coefficienti: for i in 0 to num_taps-1 generate

COEF_2(i) <= to_signed(coeff_2(i),num_bit);

end generate ciclo_coefficienti;

ciclo_moltiplicazione_parity_bit: for i in 0 to num_taps-1 generate
blocco_moltiplicazione_parity_bit: moltiplicatore_parity_bit
port map(d_FIR1(i),COEF_2(i),t_FIR1(i));
end generate ciclo_moltiplicazione_parity_bit;

-- somma su 16 bit

process(data_out_FIR1, t_FIR1)
begin
for i in 0 to num_taps-1 loop
data_out_FIR1 <= data_out_FIR1 + t_FIR1(i);
end loop;
end process;
end filtro_FIR1;
-----------------------------------------------------------------------------------------------
----------------------- Implementazione del registro a N bit -----------------------

-- Librerie --

library IEEE;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

------------------------------------------------------------------------------------

-- Entità --

entity Reg_N is
generic (num_bit : integer :=16);
port(
clk : in std_logic;
res : in std_logic;
en : in std_logic;
d : in signed(num_bit-1 downto 0);

q : out signed(num_bit-1 downto 0)
);
end Reg_N;

--ricorda che Tclk < Td/2 (per assicurarsi di prendere tutti i valori in ingresso(d))

-- Architettura --

architecture Reg_N of Reg_N is

begin
process(clk) -- sincrono
begin
if rising_edge(clk) then
if (en='1') then
if (res='0') then
q<=d;
elsif(res='1') then
q<=(others =>'0');
end if;
end if;
end if;
end process;
end Reg_N;
------------------------------------------------------------------------------------
--------------------------------- Moltiplicatore a parità del numero di bit ---------------------------------

-- Librerie --

library IEEE;
use ieee.std_logic_1164.all;
use ieee.numeric_std.all;

-- La libreria "std_logic_arith" non viene utilizzata essendo ormai obsoleta.

-------------------------------------------------------------------------------------------------------------

-- Entità --

entity moltiplicatore_parity_bit is
generic(num_bit : integer :=16);
port(
m1 : in signed(num_bit-1 downto 0);
m2 : in signed(num_bit-1 downto 0);
out_parity : out signed(num_bit-1 downto 0)
);
end moltiplicatore_parity_bit;

-------------------------------------------------------------------------------------------------------------

-- Architettura --

architecture moltiplicatore_parity_bit of moltiplicatore_parity_bit is

-- Segnali --
signal m_full : signed(2*num_bit-1 downto 0); -- risultato della moltiplicazione sul doppio dei bit
signal m_round : signed(2*num_bit-1 downto 0);
signal one : signed(2*num_bit-1 downto 0);
begin

m_full <= m1 * m2;
one <= to_signed(1,2*num_bit); -- converte " 1 " in un signed a 2*num_bit

m_round <= m_full + SHIFT_LEFT(one,num_bit-1); -- rounding
out_parity <= m_round(2*num_bit-1 downto num_bit); -- fine rounding

end moltiplicatore_parity_bit;
------------------------------------------------------------------------------------------------------------- [code]

Ciao a tutti.