Unconnected pins, nets: Wie handhaben? Pull-Down?

[Patrick B. (p51d)]

Hallo allerseits

Ich habe bei einem aktuellen Projekt einen kleinen Schönheitsfehler 
gefunden.
Eine Uhr habe ich aus mehreren generischen Zählern mit Carry-In und 
Carry-Out aufgebaut. Nur hat jetzt der letzte Zähler (10ner der Stunden) 
einen offenen Carry-Out.
Wie kann ich hier jetzt eine Fehlermeldung unterdrücken? Quasi ein 
Pull-Down Widerstand einsetzen?
Ich habe schon "open" versucht, aber das hat nicht viel gebracht...

Besten Dank für die Hilfe
MFG
Patrick

[Tobias L. (murxwitz)]

da dürfte doch "nur" ein Warnung raus kommen, und davon hat man bei 
VHDL/Verilog gern ne ganze Liste, musst die halt durchgehen und schauen 
ob es da ein Problem gibt oder nicht.
Ist nicht wie bei C wo man (meist) ohne Warnungen enden möchte.

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

Patrick B. schrieb:
> Wie kann ich hier jetzt eine Fehlermeldung unterdrücken?
Ließ mal deine Frage, und dann beantworte (ohne zusätzliches 
Hintergrundwissen) diese hier: wer (also genau: welcher Teil welcher 
Toolchain) sollte bei einem offenen Ausgang welche Fehlermeldung 
ausspucken? Wie hast du die "generischen Zähler" verdrahtet?

[FPGA Pongo (Gast)]

Das überflüssige Carry muss wie alle anderen Signale selbstverständlich 
abgeschlossen werden. Einfach auf einen Ausgang legen und mit 50 Ohm 
terminieren. Dann ist die Synthese auch zufrieden.

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

FPGA Pongo schrieb im Beitrag #4148649:
> mit 50 Ohm terminieren.
Aufgrund des dadurch unnötig hohen statischen Stromverbrauchs würde ich 
aber eher eine AC Terminierung über einen zusätzlichen 100nF Kondensator 
vorsehen...

[Patrick B. (p51d)]

Der Grundzähler sieht so aus:

entity counter is
   Generic (cnt_width : INTEGER := 4;
         cnt_up_limit : INTEGER := 9);
    Port ( ci : in  STD_LOGIC;
           load_val : in  STD_LOGIC_VECTOR (cnt_width-1 downto 0);
           load : in  STD_LOGIC;
        en : in STD_LOGIC;
           rst : in  STD_LOGIC;
           clk : in  STD_LOGIC;
           co : out  STD_LOGIC;
           count : out  STD_LOGIC_VECTOR (cnt_width-1 downto 0));
end counter;

Die Uhr selber ist dann so aufgebaut:

entity timer is
    Port ( rst : in  STD_LOGIC;
           clk : in  STD_LOGIC;
        en : in STD_LOGIC;
           load_h10 : in  STD_LOGIC_VECTOR (1 downto 0);
           load_h1 : in  STD_LOGIC_VECTOR (3 downto 0);
           load_min10 : in  STD_LOGIC_VECTOR (2 downto 0);
           load_min1 : in  STD_LOGIC_VECTOR (3 downto 0);
           load_h : in  STD_LOGIC;
           load_min : in  STD_LOGIC;
           rst_sec : in  STD_LOGIC;
           h10 : out  STD_LOGIC_VECTOR (1 downto 0);
           h1 : out  STD_LOGIC_VECTOR (3 downto 0);
           min10 : out  STD_LOGIC_VECTOR (2 downto 0);
           min1 : out  STD_LOGIC_VECTOR (3 downto 0);
           sec10 : out  STD_LOGIC_VECTOR (2 downto 0);
           sec1 : out  STD_LOGIC_VECTOR (3 downto 0));
end timer;

architecture Behavioral of timer is
  COMPONENT counter  
  GENERIC (cnt_width : INTEGER;
        cnt_up_limit : INTEGER);
  PORT(
    ci : IN std_logic;
    load_val : IN std_logic_vector(cnt_width-1 downto 0);
    load : IN std_logic;
    en : in STD_LOGIC;
    rst : IN std_logic;
    clk : IN std_logic;          
    co : OUT std_logic;
    count : OUT std_logic_vector(cnt_width-1 downto 0)
    );
  END COMPONENT;
  
  signal sec1_co : std_logic;
  signal sec10_co : std_logic;
  signal min1_co : std_logic;
  signal min10_co : std_logic;
  signal h1_co : std_logic;
  signal h10_co : std_logic;
  
  signal rst_h : std_logic;
  signal h1_reg : std_logic_vector(3 downto 0);
  signal h10_reg : std_logic_vector(1 downto 0);
begin
   -------------------------------------------------------------------------------
  -- Komponenten instaziieren
   -------------------------------------------------------------------------------
  -- Stunden: Zehner-Zähler
  h10_cnt: counter GENERIC MAP(
      cnt_width => 2,
      cnt_up_limit => 2
    )
    PORT MAP(
    ci => h1_co,
    load_val => load_h10,
    load => load_h,
    en => en,
    rst => rst_h,
    clk => clk,
    co => h10_co,
    count => h10_reg
  );
  -- Stunden: Einer-Zähler
  h1_cnt: counter GENERIC MAP(
      cnt_width => 4,
      cnt_up_limit => 9
    )
    PORT MAP(
    ci => min10_co,
    load_val => load_h1,
    load => load_h,
    en => en,
    rst => rst_h,
    clk => clk,
    co => h1_co,
    count => h1_reg
  );
  
  -- Minuten: Zehner-Zähler
  min10_cnt: counter GENERIC MAP(
      cnt_width => 3,
      cnt_up_limit => 5
    )
    PORT MAP(
    ci => min1_co,
    load_val => load_min10,
    load => load_min,
    en => en,
    rst => rst,
    clk => clk,
    co => min10_co,
    count => min10
  );
  -- Minuten: Einer-Zähler
  min1_cnt: counter GENERIC MAP(
      cnt_width => 4,
      cnt_up_limit => 9
    )
    PORT MAP(
    ci => sec10_co,
    load_val => load_min1,
    load => load_min,
    en => en,
    rst => rst,
    clk => clk,
    co => min1_co,
    count => min1
  );

  -- Sekunden: Zehner-Zähler
  sec10_cnt: counter GENERIC MAP(
      cnt_width => 3,
      cnt_up_limit => 5
    )
    PORT MAP(
    ci => sec1_co,
    load_val => "000",
    load => rst_sec,
    en => en,
    rst => rst,
    clk => clk,
    co => sec10_co,
    count => sec10
  );
  -- Sekunden: Einer-Zähler
  sec1_cnt: counter GENERIC MAP(
      cnt_width => 4,
      cnt_up_limit => 9
    )
    PORT MAP(
    ci => '1',
    load_val => "0000",
    load => rst_sec,
    en => en,
    rst => rst,
    clk => clk,
    co => sec1_co,
    count => sec1
  );  
  
  
   -------------------------------------------------------------------------------
  -- Kombinatorik
   -------------------------------------------------------------------------------
  -- Handhabung des Einerzählers der Stunde
  rst_h <= '1' when ((rst = '1') or ((h1_reg = "0100") and (h10_reg = "10"))) else '0';
  h1 <= h1_reg;
  h10 <= h10_reg;

end Behavioral;

Das Signal h10_co ist zwar "verdrahtet", aber nirgends angeschlossen. 
Auch nicht auf einem Pin (da die Uhr selber dieses nicht nach aussen 
führt).
Ob ich anstelle h10_co oder open zuweise, spielt bei der Synthese keine 
rolle. Es gibt immer die Warnung, dass ein Signal nicht angeschlossen 
ist.

Kann dies nicht intern irgendwie gelöst werden, oder muss hier zwingend 
eine externe Beschaltung (Widerstand, Kondensator) ran?

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

Patrick B. schrieb:
> Es gibt immer die Warnung, dass ein Signal nicht angeschlossen ist.
>
> Kann dies nicht intern irgendwie gelöst werden
Nein. Denn du deklarierst den Ausgang, verwendest ihn aber nicht. 
Und das wird dir da gemeldet.
Da gibts 2 Lösungswege:
Mach einen zusätzlichen Zähler ohne Carry-Ausgang.
Oder:
Ignoriere die Warnung. Du selber weißt, dass das so sein muss und keinen 
Fehler darstellt.

> oder muss hier zwingend
> eine externe Beschaltung (Widerstand, Kondensator) ran?
Das waren zwei kleine Witzlein. Kein Mensch wird einen ungenutzten 
Ausgang auf einen Pin routen. Dafür sind Pins viel zu wertvoll.

BTW: dieser strukturelle Beschreibungsstil ist hoffentlich nur zur 
Übung. Denn das Ganze ist so extrem unübersichtlich...
Ich würde das eher so machen wie im 
Beitrag "kruder Fehler bei FPGA-Programmierung (ISE WEBpack-Schematic)"

[Patrick B. (p51d)]

Lothar Miller schrieb:
> BTW: dieser strukturelle Beschreibungsstil ist hoffentlich nur zur
> Übung. Denn das Ganze ist so extrem unübersichtlich...
> Ich würde das eher so machen wie im
> Beitrag "kruder Fehler bei FPGA-Programmierung (ISE WEBpack-Schematic)"

Also, ich hab das heute mal andersrum versucht: Ein 4-Bit Zähler, 
welcher über einen Eingang definiert wird (Top-Val). Und dann schön ein 
Schema... klappte soweit so gut. Nur wurde es dann sehr mühsam, gewisse 
Load-Werte in der Breite anzupassen (5er Zähler haben nur 3-Bit Breite, 
der 10ner-Stundenzähler sogar nur 2). Hier mussten die Load-Busse 
jeweils aufgetrennt, Buffers hinzugefügt und dann korrekt nach aussen 
geführt werden. Also entweder man generiert sich 3 verschiedene 
Grundzähler, die dann auch schön im Schema verwendet werden können, oder 
wie macht man das schön (und simpel sowie gut wartbar)?

Das Schema war am Schluss (der Einfacheithalber nur 1 Grundzähler) nicht 
mehr zu lesen. Mein Ansatz hat das ganze über Generics und über 
Verkettung der Signale zur richtigen Breite doch ziemlich übersichticher 
wirken lassen (auf dieser Ebene).

Ich stimme dir voll und ganz zu, dass man irgendwann ein Schema besser 
lesen kann, aber da ich es noch nicht herausgefunden habe, wie man 
Generics in Schemasymbolen setzt (die dann auch Bussbreiten usw. 
anpasst), bleibe ich bei einer Misch-Form.

[Graf Iker (Gast)]

Für eine digitale Schaltung ein Schema zu zeichnen, heisst nicht, das 
unbedingt mit den schlimmen toolz der Hersteller zu tun. Man kann sowas 
auch schnell in Visio oder einem anderen Programm malen und jeweils 
aktualisieren, während die Synthese läuft. Das geht schneller und 
entspannter.