Xillinx ISE optmiert mir Leitungen weg!

[Wisler E. (wisler)]

Hi Leute,

ich bin leider noch etwas neu auf dem Gebiet VHDL. Ich versuche gerade 
einen Pseudozufallsgenerator zu programmiern. Ich denke mein Code müsste 
auch soweit funktionineren nur tut mir der Kompiler immer die Leitungen 
weg optimieren. Er sagt sie würden nicht verwendet werden, aber ich habe 
sie immer in der PORT MAP verwendet. Ich versteh einfach net was ich 
falsch mache. :-(

So möchte ich hier gerne zwei Fragen stellen:

1.)
Hier sind mal die warnings die kommen:

WARNING:Xst:646 - Signal <s_intern<0>> is assigned but never used. This 
unconnected signal will be trimmed during the optimization process.
WARNING:Xst:1290 - Hierarchical block <N_1_Stufen[0].G0.G0> is 
unconnected in block <e_test_maschine>.
   It will be removed from the design.
WARNING:Xst:1290 - Hierarchical block <N_1_Stufen[1].GN_2.G0> is 
unconnected in block <e_test_maschine>.
   It will be removed from the design.
WARNING:Xst:1290 - Hierarchical block <N_1_Stufen[2].GN_2.G0> is 
unconnected in block <e_test_maschine>.
   It will be removed from the design.
WARNING:Xst:1290 - Hierarchical block <N_1_Stufen[3].GNN.G_0> is 
unconnected in block <e_test_maschine>.
   It will be removed from the design.


Ich werde den Code mal im Anhang einfügen. Leider führten meine 
bisherigen Ideen nicht zum Erfolg. Vielleicht weiß hier jemand warum die 
Leitungen wegoptmiert werden. Ich komme so leider nicht weiter :-(

2.) Vielleicht kann mir noch einer verraten, wie ich eine Konstante für 
alle Entitys deklarieren kann. So könnte ich dann mein Schieberigister 
und den Rest des Programms über eine Konstante steuern und bestimmen 
wieviele Bit es breit ist.

Ich danke schon mal fürs lesen.


Grüße Wisler

[Anguel S. (anguel)]

Wisler Electronics schrieb:

> Ich denke mein Code müsste
> auch soweit funktionineren nur tut mir der Kompiler immer die Leitungen
> weg optimieren. Er sagt sie würden nicht verwendet werden, aber ich habe
> sie immer in der PORT MAP verwendet. Ich versteh einfach net was ich
> falsch mache. :-(

Die Tools sind einfach so intelligent, dass sie immer schauen, ob alle 
Signale tatsächlich genutzt werden. Wenn sie nicht verbunden oder 
konstant sind, werden sie wegoptimiert, um Ressourcen zu sparen. In 
99,9% der Fälle tun die Tools das richtige wenn man sich alles genau 
anschaut.

Grüße,
Anguel

[Georg A. (Gast)]

Die erste Warning ist offensichtlich zutreffend. Bei den anderen nehme 
ich stark an, dass da in der Generate-Wüste irgendein Index-Offset 
falsch ist, bin jetzt zu faul, das im Kopf einzusetzen ;) Jedenfalls 
liegt das nahe, wenn schon s_intern(0) so ziellos ist...

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

>     IF (RESET = '1')  THEN    --asynchroner Reset
Wenn du schon Xilinx Bausteine verwendest, dann lies mal das WP272.

Was ist denn das für ein unglaublich umständlicher Code?
Mußt du das so machen? Oder hast du das einfach so gelernt?

Ein generisches Schieberegister in VHDL sieht so aus:

   process (clk) begin
     if rising_edge(clk) then
       if shift_enable='1' then
         reg <= reg(reg'left-1 downto 0) & neues_bit;
       end if;
     end if;
   end process;

Oder kürzer (aber genau gleich) so:

   process begin
     wait until rising_edge(clk);
     if shift_enable='1' then
       reg <= reg(reg'left-1 downto 0) & neues_bit;
     end if;
   end process;

Oder noch kürzer und concurrent/nebenläufig/ohne Prozess:

   reg <= reg(reg'left-1 downto 0) & neues_bit when rising_edge(clk) and shift_enable='1';

[Wisler E. (wisler)]

Zuerst einmal danke für die Hilfen, aber weiter gekommen bin ich jetzt 
leider noch nicht.

@Anguel S.
Ja das denke ich mir, dass die Tools immer 99,9% das richtige machen. 
Deshalb wollte ich einfach mal hier was posten und sehen ob ich 
vielleicht einen Denkfehler habe und man das bei VHDL nicht so machen 
kann oder darf.

@Georg A.
Hier nochmal die Codezeilen, wo die Warnings kommen. Ich denke schon, 
dass s_intern(0) vergeben habe, aber irgendwie sagt der Compiler es wäre 
überflüssig un schmeißt sie weg. :-( Siehe die siebte Zeile in dem Code 
unten.

SIGNAL intern_ff_out: std_logic_vector(0 TO nn-1);
  SIGNAL intern_schiebe_in:  std_logic;
  SIGNAL s_intern:  std_logic_vector(0 TO nn-1);
  
  
  BEGIN
    N_1_Stufen:    FOR ii IN 0 TO  (nn -1) GENERATE
                G0: IF (ii = 0) GENERATE
                  G0: e_xor_and PORT MAP(xi=>intern_ff_out(0), ki=>kn_in(0), xori=>s_intern(1), y=>s_intern(0));
                END GENERATE G0;
                
                GN_2: IF (ii > 0 AND ii < nn -1) GENERATE
                  G0: e_xor_and PORT MAP(xi=>intern_ff_out(ii), ki=>kn_in(ii), xori=>s_intern(ii +1), y=>s_intern(ii));
                END GENERATE GN_2;
                
                GNN: IF (ii = nn -1) GENERATE
                  G_0: e_and PORT MAP(a=>intern_ff_out(nn -1), b=>kn_in(nn -1), y=>s_intern(nn -1));
                END GENERATE GNN;
          END GENERATE N_1_Stufen;
    
    Schieberegister:    e_schieberegister PORT MAP(intern_schiebe_in, clk, reset, intern_ff_out);
    select_mode:      e_switch_mode PORT MAP(dat_in, mode, intern_ff_out(nn -1), intern_schiebe_in);
    SIGNAL_OUT:        xn_out <= intern_ff_out;
    
END a_test_maschine;

@Lothar Miller
Naja irgendwie haben wir das schon so gelernt. :-( Wir sollen eigentlich 
immer in Blöcken denken. Da habe ich mir gedacht baust du die ein D-Flip 
Flop und dann kannst du es N - mal verwenden und baust dir ein N-Bit 
Schieberegister auf. Das funktioniert bis jetzt auch ganz gut. Ich 
finde, aber auch dass es so sehr mühsam ist zu programmieren und man 
muss immer genau überlegen wie man was macht.
Naja das mit dem Reset wollte ich eigentlich schon asynchron zum Takt 
haben. Ist das schlimm oder was meinst du mit der ersten Zeile?
Dein Schieberegister ist natürlich sehr viel kürzer wie meins, nur ich 
versteh noch nicht ganz was die Zeile macht:

reg <= reg(reg'left-1 downto 0) & neues_bit;

Das ist doch einfach ein Bit verschieben oder?

Ich hoffe vielleicht kann mit jetzt einer besser helfen, bin halt leider 
noch nicht so ganz vertraut mit VHDL. Ich denke da braucht man sehr 
lange bis man wirklich mal viel damit machen kann.

Die Konstante global zu machen, wäre für mich schonmal ein Anfang. :-)

[Wisler E. (wisler)]

So ich habe den Fehler gefunden. Es tut mir leid, aber ich habe wohl 
eine Leitung vergessen zu verbinden. Gibt es den keine leichtere 
Möglichkeit Blöcke miteinander zu verbinden ohne den Generate Befehl. Da 
kann man ja leicht mal durcheinander kommen.

Aber das Problem mit der Konstanten habe ich immer noch :-(
Wie kann ich den eine Konstante deklarieren, dass Sie für alle Entitys 
verfügbar ist und ich nicht in jeder Entity sie einzeln deklarieren 
muss.

[Georg A. (Gast)]

> Ich denke schon, dass s_intern(0) vergeben habe, aber
> irgendwie sagt der Compiler es wäre überflüssig un schmeißt sie weg.

Als Ausgang schon, aber welche der anderen Zeilen hat es als Eingang?

> Gibt es den keine leichtere Möglichkeit Blöcke miteinander
> zu verbinden ohne den Generate Befehl?

Jein. Ein F*ckup kommt bei dir schon mal daher, dass du die Sonderfälle 
vom Anfang und Ende in die Forschleife reinsteckst und nochmal 
(zwangsweise) mit if verknüpfst. Das ist doch völlig überflüssig. Die 
kann man ohne generate instanziieren (bei nn>=2).

[Anguel S. (anguel)]

Wisler Electronics schrieb:
> Aber das Problem mit der Konstanten habe ich immer noch :-(
> Wie kann ich den eine Konstante deklarieren, dass Sie für alle Entitys
> verfügbar ist und ich nicht in jeder Entity sie einzeln deklarieren
> muss.

Ich bastele mir ein Package z.B. so:

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

package mypackage is

  constant CONST_A : std_logic_vector(7 downto 0) := X"00";
  constant CONST_B : std_logic_vector(7 downto 0) := X"01";
end mypackage;

Dann wenn du in einer anderen VHDL Datei auf die Konstante zugreifen 
willst, musst du das Package einbinden:

use work.mypackage.all;

Grüße,
Anguel

[Wisler E. (wisler)]

Zuerst einmal Danke für euere Antworten es hat super geklappt. Doch eine 
Frage hätte ich noch zu VHDL.

Und zwar bin ich gerade dabei einen Zähler zu bauen, der Funktioniert 
auch wunderbar, da ich aber das Ausgangssignal also den Zählerstand 
nicht brauche habe ich es in einer Variablen rechnen lassen. Um es so 
dem Übergeordneten Block nicht übergeben zu müssen.
Dies geht doch auch oder? Gibt es da noch eine andere Möglichkeit?

Ausserdem kann ich mit dem Zähler einen Anfangswert laden. Doch hier 
scheitere ich. Ich weiß nicht wieso der Comiler mir das Signal immer als 
Warning bringt. Ich weiße ihm einen Konstanten Wert zu. Dies mache ich 
in einem Übergeordneten Modul/Block. Doch hier geht es wohl irgendwie 
nicht. Vielleicht kann mir einer erklären woran das liegt. Also ich 
verstehe dich Sprache VHDL noch nicht wirklich, da fand ich den Einstieg 
in C irgendwie leichter. :-(

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use IEEE.NUMERIC_STD.ALL;

entity e_main is
PORT(    clk_50MHz: IN std_logic);
end e_main;

architecture a_main of e_main is

component e_timer_no_out
GENERIC(NN: integer);
Port (  Clk : in  STD_LOGIC;  --Takteingang 
            Rst : in  STD_LOGIC;  --Reset 
            --ZZ : out  STD_LOGIC_VECTOR (NN-1 downto 0);-- Zählerstand 
            OV : out STD_LOGIC;  --Überlaufsignal 
            LoadV : in  STD_LOGIC_VECTOR (NN-1 downto 0);--Nachladew
            Enable : in  STD_LOGIC;  --Timer Start/Stop 
            Set : in  STD_LOGIC);    --Nachladewert einspeichern 
end component;


--Einstellungen für 1MHz Takt
constant c_50MHz_to_1MHz  : integer:=50; 
constant c_NN_1MHZ  : integer:=6;    --ceil(ln(Teiler50)/ln(2)) 
constant c_LV_1MHZ  : STD_LOGIC_VECTOR (c_NN_1MHZ-1 downto 0) :=conv_std_logic_vector(-c_50MHz_to_1MHz +1, c_NN_1MHZ); 

signal  s_OV_SET_1MHz:  std_logic := '0';
signal  s_outt_1MHz:  std_logic := '0';

Begin 
  clk_50MHz_to_1MHZ: 
    e_timer_no_out
    Generic Map(NN => c_NN_1MHZ) 
    Port Map (    Clk   => clk_50MHz,--CLK_50MHZ,   
              Rst   => '0',
              OV   => s_outt_1MHz,    --Unsymmetrisches Signal 
              LoadV => c_LV_1MHZ, 
              Enable => '1',
              Set   => s_OV_SET_1MHz); 
 
    s_OV_SET_1MHz <=  s_outt_1MHz;
end a_main;

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_ARITH.ALL;
use IEEE.STD_LOGIC_UNSIGNED.ALL;
use IEEE.NUMERIC_STD.ALL;

entity e_timer_no_out is
Generic (NN:integer:=32); 
Port (  Clk : in  STD_LOGIC;  --Takteingang 
            Rst : in  STD_LOGIC;  --Reset 
            OV : out STD_LOGIC;  --Überlaufsignal 
            LoadV : in  STD_LOGIC_VECTOR (NN-1 downto 0);--Nachladew
            Enable : in  STD_LOGIC;  --Timer Start/Stop 
            Set : in  STD_LOGIC);    --Nachladewert einspeichern 
end e_timer_no_out;

architecture a_timer_no_out of e_timer_no_out is

signal s_ov: std_logic;--Overflow Signal

begin 
  process(clk, rst)
  
  variable tz: std_logic_vector(NN downto 0) := (others => '0');
  Begin 
    if(Rst='1')then        -- Resetaktion 
      tz := '0' & LoadV;--conv_std_logic_vector(0,NN-1); 
    elsif(clk'event AND clk='1')then  --Taktsynchrones Umfeld 
      if(Set='1')then     --Nachladevorgang 
        tz:= '0' & LoadV; 
      elsif(Enable='1')then    --Zähler Start/Stop 
        tz := tz+1;    --Zählerstand erhöhen 
      end if; 
      
      if( tz(NN) = '1') then
        s_ov <= '1';
      else
        s_ov <= '0';
      end if;
    end if;
  End Process; 
 
  ov <= s_ov;          --Überlaufsignal 
end a_timer_no_out;

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Wisler Electronics schrieb:
> Um es so dem Übergeordneten Block nicht übergeben zu müssen.
> Dies geht doch auch oder?
Schon, aber...
> Gibt es da noch eine andere Möglichkeit?
Mach den Zähler besser als Signal, wenn du das Verhalten von Variablen 
noch nicht kannst. Du MUSST ja nicht alle Signale auch über den Port der 
Entity nach "oben" geben...
Beitrag "Variable vs Signal"

Wisler Electronics schrieb:
> elsif(clk'event AND clk='1')then  --Taktsynchrones Umfeld
Warum, frage ich mich, schreibt das eigentlich alle Welt so umständlich 
(und eigetnlich auch falsch)? Es gibt doch die elegante Funktion 
rising_edge()...

Wisler Electronics schrieb:
> use IEEE.STD_LOGIC_ARITH.ALL;
> use IEEE.STD_LOGIC_UNSIGNED.ALL;
> use IEEE.NUMERIC_STD.ALL;
Nein, bitte nicht schon wieder...
Siehe den Beitrag "IEEE.STD_LOGIC_ARITH.ALL obsolete"
Und einige mehr...