delucagiovanni forum

Salve a tutti, ho implementato un semplice filtro FIR (in allegato) inserendo i coefficienti, che ho chiamato ca e cb, come costanti. Però quando cambio i valori ai coefficienti e vado a compilare il file mi escono i seguenti warning:

Warning (13024): Output pins are stuck at VCC or GND
Warning (13410): Pin "data_out[7]" is stuck at GND
Warning (13410): Pin "data_out[8]" is stuck at GND
Warning (13410): Pin "data_out[9]" is stuck at GND

N.b. Avendo dichiarato tali costanti come degli integer metto sempre dei valori interi rispettando anche l'intervallo in cui cadono gli integer. Però mi dà questi warning che non riesco a capire. Inoltre se poi imposto

constant ca : integer := 31;
constant cb : integer := 31;
non mi dà nessun warning!!!
Vi allego il codice sperando che nel codice si possa l'individuare l'errore che commetto

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;
--------------------------------------------------------------
entity filtro_FIR is
      generic (
                  num_bit  : integer :=5;
                  num_taps : integer :=4
                  
               );
         port(

                    clk        : in std_logic;
                    reset      : in std_logic;
            
                    data_in    : in unsigned(num_bit-1 downto 0);             
                    data_out   : out unsigned(2*num_bit-1 downto 0)   
                                                                         
               );
end filtro_FIR;

architecture filtro_FIR of filtro_FIR is

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

constant ca : integer := 7;
constant cb : integer := 15;



signal d0,d1,d2,d3 : unsigned(num_bit-1 downto 0);
signal t0,t1,t2,t3 : unsigned(2*num_bit-1 downto 0);    --prodotti parziali a 2*num_bit (num_bit x num_bit)
       

begin

  d0 <= data_in;
 
  delay1 : reg
  port map(clk,reset,d0,d1);
 
  delay2 : reg
  port map(clk,reset,d1,d2);
 
  delay3 : reg
  port map(clk,reset,d2,d3);
 

  t0 <= d0 * conv_unsigned(ca,5);    -- conversione in binario
  t1 <= d1 * conv_unsigned(cb,5);
  t2 <= d2 * conv_unsigned(cb,5);
  t3 <= d3 * conv_unsigned(ca,5);
 

  --per come quartus gestisce le somme, occorre dare
  --agli addendi la stessa ampiezza in bit,
  --quindi posso usare la conv_unsigned(...)
 
  data_out <= conv_unsigned(t0,2*num_bit)+conv_unsigned(t1,2*num_bit)+conv_unsigned(t2,2*num_bit)+conv_unsigned(t3,2*num_bit);

end filtro_FIR;

-- Implementazione del blocco di ritardo elementare mediante flip-flop con reset asincrono -- che ho messo in un altro file vhdl

library IEEE;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_signed.all;

entity reg is
generic (num_bit : integer :=5);
 port(
           
           reg_clk    : in std_logic;
           reg_reset  : in std_logic;
          
           D          : in  unsigned(num_bit-1 downto 0);
           Q          : out unsigned(num_bit-1 downto 0)
          
     );
end reg;

architecture reg of reg is
begin
   
   process(reg_clk,reg_reset)
   begin
         
          if reg_reset='0' then
             Q <= (others => '0');
           else if reg_clk'event and reg_clk='1' then
              Q <= D;
           end if;
          end if;
   end process;
end reg;



Bene, vedo che stai facendo progressi

Warning (13024): Output pins are stuck at VCC or GND
Warning (13410): Pin "data_out[7]" is stuck at GND
Warning (13410): Pin "data_out[8]" is stuck at GND
Warning (13410): Pin "data_out[9]" is stuck at GND

E' corretto dal punto di vista del compilatore. Il warning ti dice che i data_out[7, 8, 9] varranno sempre 0 perché con tali coefficienti scelti il valori di uscita non potrà essere superiore ad un certo numero e quindi avrà alcuni bit sempre a zero.
Puoi ignorare il warning se va bene così.

Ciao

Ti ringrazio per l'aiuto. I miei progressi sono anche merito dei vostri consigli (riferendomi anche al Professore DeLuca). Ciao

alfo84, che tipo di filtro è quello che hai allegato?
è un passa basso o altro?

vorrei sapere se è possibile realizzare un passa banda di II° ordine per filtrare freq tra 100 e 200 Hz.

ciao a tutti

Ciao Altero, in realtà non so se è un passa basso o altro, seguendo la funzione di trasferimento di un filtro fir mi è venuto fuori questo codice. Poi non so come fare per ottenere un fir passo basso o altro.

PS Io penso che il codice che ho scritto valga per un filtro fir in generale. Poi in base ai valori dei coefficienti che gli dai potrà essere un filtro passa basso o altro. Ad esempio se utilizzi matlab e in particolare il tool fdatool puoi costruirti un filtro fir di tipo passa basso o altro e ricavarti i rispettivi valori dei coefficienti. Dopo di che prendi questi coefficienti e li inserisci nel codice.

Più di questo nn so dirti,spero di averti aiutato in questo modo.

grazie alfo per la pronta risposta,

ma tu non hai simulato il progetto? che risultati hai ottenuto?
cosa dai in ingresso e cosa ottenieni in uscita?

Ah proposito guarda che il codice l'ho modificato leggermente in modo da poter considerare valori signed e avere l'uscita del filtro fir sullo stesso numero di bit dell'ingresso:

[code]--------------- 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_senza_cicli 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 : out signed(num_bit-1 downto 0) -- sullo stesso numero di bit

);

end filtro_FIR_senza_cicli;
---------------------------------------------------------------
-- Architettura --
architecture filtro_FIR_senza_cicli of filtro_FIR_senza_cicli 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 c2_0 : integer := 35;
constant c2_1 : integer := 11;



signal d0,d1,d2,d3 : signed(num_bit-1 downto 0);
signal t0,t1,t2,t3 : signed(2*num_bit-1 downto 0); --prodotti parziali a 2*num_bit (num_bit x num_bit)
signal f0,f1,f2,f3 : signed(num_bit-1 downto 0);



begin

d0 <= data_in;



delay1 : reg
port map(clk,reset,d0,d1);

delay2 : reg
port map(clk,reset,d1,d2);

delay3 : reg
port map(clk,reset,d2,d3);



t0 <= d0 * conv_signed(c2_0,num_bit); -- conversione in binario di ca --> conv_unsigned(...)
t1 <= d1 * conv_signed(c2_1,num_bit);
t2 <= d2 * conv_signed(c2_1,num_bit);
t3 <= d3 * conv_signed(c2_0,num_bit);



f0 <= t0(num_bit-1 downto 0);
f1 <= t1(num_bit-1 downto 0);
f2 <= t2(num_bit-1 downto 0);
f3 <= t3(num_bit-1 downto 0);



data_out <= f0+f1+f2+f3;


end filtro_FIR_senza_cicli;
---------------------------------------------------------------
-- Implementazione del blocco di ritardo elementare
-- mediante un registro a n bit (flip-flop di tipo D con reset asincrono) --

library IEEE;
use ieee.std_logic_1164.all;
use ieee.std_logic_arith.all;
use ieee.std_logic_signed.all;

entity reg is
generic (num_bit : integer :=3);
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 reg;

architecture reg of reg is
begin

process(reg_clk,reg_reset)
begin

if reg_reset='1' then
Q <= (others => '0');
else if reg_clk'event and reg_clk='1' then
Q <= D;
end if;
end if;
end process;
end reg;
[code]

Ora sto cercando di scrivere lo stesso codice per il fir utilizzando però dei cicli for in modo da evitare di scrivere tante linee di codice.
Vedi l'altro topic implementazione filtro fir con cicli for. Però mi dà un errore che non riesco a risolvere

Allora in realtà un simulazione con modelsim l'ho fatta però stavo cercando di capire i risultati.
Voglio realizzare pure un testbench di tutta la struttura.
cmq ti spiego a grandi linee le difficoltà che ho a capire i risultati:

ci sono 3 fip flop (in realtà dovremmo parlare di 3 registri a n bit), mi hanno consigliato di simulare un solo flip flop e vedere l'uscita.
Allora per come è progettato il flip flop nel file reg dovrebbe accadere questo:

se ad esempio l'ingresso lo impostiamo a 001, e reset a 0 e clock imponiamo un frequenza di 100 ps, vedi dalla simulazione che quando il clock si alza proprio sul fronte di salita l'uscita Q diventa uguale all'ingresso D. Questo so fare, però mi diventa tutto più difficile quando ho piu flip flop da analizzare.

Io in questi giorni proverò a fare questa simulazione, prova anche tu e poi magari se ti va ci confrontiamo.

alfo, ok, grazie per l'aggiornamento
ma non hai risposto alla mia domanda.

il filtro che hai allegato, che tipo di filtro è?
ne esistono di vario tipo, come quelli analogici, ma non riesco a decifrare il tuo.
tu per quale applicazione lo stai descrivendo?

ciao

Io per farti capire devo realizzare un filtro di interpolazione con struttura Farrow modificata che presenta all'interno 3 filtri fir. Nell'articolo gia mi sono stati dati i valori dei coefficienti però non dice nulla sul tipo di filtro FIR. Ora che me lo chiedi me lo chiedo pure io. Devo leggere di nuovo l'articolo, per quanto riguarda il codice invece che ho preso da internet non fa questa distinzione tra passa basso o altro.

Se mi dai la tua email ti mando i file dove ho preso il codice per il filtro fir, cmq non fa questa distinzione, la traccia chiede solamente di realizzare un filtro fir.