Folgenden code habe ich mir hier www.youtube.com/watch?v=Ob7B6x5g6tw 
abgeguckt.

Eigentlich idiotensicher, doch nicht bei mir :)

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

entity Main is
  port (
    CLK : in std_logic;
    OUT_LED : out std_logic_vector(254 downto 0)
  );
end Main;

architecture Behavioral of Main is
  signal COUNTER: std_logic_vector(254 downto 0);
  signal PRESCALER: std_logic_vector(31 downto 0);
begin

  CounterProcess: process (CLK)
  begin
    if rising_edge(CLK) then
      if PRESCALER < "100110001001011010000000" then
        PRESCALER <= PRESCALER + 1;
      else
        PRESCALER <= (others => '0');
        COUNTER <= COUNTER + 1;
      end if;
    end if;
  end process;
  
  OUT_LED <= COUNTER;

end Behavioral;

Ich habe einen 10MHz Takt der eine (!) LED im Sekundentakt (da Prescaler 
auf 10.000.000) zum Leuchten bringt (1 Sek. an 1 Sek. aus => Takt ok).

Wie schaff ich es, die 255 LEDs hochzuzählen...

In dem Du 2 hoch 254 Sekunden wartest,
oder den Takt erhöhst,
oder die LEDs mit Schieberegister fährst.

trollo schrieb:
> if PRESCALER < "100110001001011010000000"
Ganz böse, da ressourcenfressend... Lieber bei dieser Zahl anfangen, 
nach unten zählen, und auf Gleichheit mit 0 prüfen.

Tss, vielleicht einfach mal darüber nachdenken, was Du da machst, Du 
Trollo! Ein Zähler, der im Sekundentakt eine 255 Bit Zahl hochzählt ... 
wenn dann davon 100 LEDs nicht angeschlossen sind, oh Mann.

2^100 Sekunden warten ist echt keine Freude.

Ich bin aber doch noch darauf gekommen, als ich darüber nachgedacht 
habe, wie dieses Blinken zustande kommen kann. Das letzte Bit toggelt 
fleißig und die höheren sind nicht angeschlossen...

Sorry, dass ich Euch mit dieser Dummheit belästigt habe.

Danke an Bernie und den Meisterstricker.

Eine gute Nacht wünsche ich Euch :)

Strickwettbewerbgewinner schrieb:
> Ganz böse, da ressourcenfressend

Den Vergleich würde ich gerne sehen. Wie beschreibst du das dann bitte?

Prozess 1 braucht 285LE auf einem Cyclone 4,
Prozess 2 hingegen braucht 303LE.

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.Numeric_std.ALL;

entity bla is
  port (
    CLK : in std_logic;
    OUT_LED : out std_logic_vector(254 downto 0)
  );
end bla;

architecture Behavioral of bla is
  signal COUNTER: unsigned(254 downto 0);
  signal PRESCALER: unsigned(23 downto 0);
begin

--  CounterProcess: process (CLK)
--  begin
--    if rising_edge(CLK) then
--      if PRESCALER < "100110001001011010000000" then
--        PRESCALER <= PRESCALER + 1;
--      else
--        PRESCALER <= (others => '0');
--        COUNTER <= COUNTER + 1;
--      end if;
--    end if;
--  end process;
  
   CounterProcess: process (CLK)
  begin
    if rising_edge(CLK) then
      if PRESCALER = 0 then
        PRESCALER <= "100110001001011010000000";
        COUNTER <= COUNTER + 1;
      else
        PRESCALER <= PRESCALER - 1;
      end if;
    end if;
  end process;
  
  OUT_LED <= std_logic_vector(COUNTER);

end Behavioral;

hjk schrieb:
> Strickwettbewerbgewinner schrieb:
>> Ganz böse, da ressourcenfressend
>
> Den Vergleich würde ich gerne sehen. Wie beschreibst du das dann bitte?

Das hat er doch auch nur irgendwo gelesen und blind übernommen ;-) 
Mitläufermentalität

Wenn das letzte Bit im Vergleich mit drin ist, ist es egal, ob grösser 
oder grösser-gleich.

Lothar Miller schrieb:
>Es ist bei FPGA-Designs durchschnittlich eher schlecht, auf "gleich" zu
>vergleichen. Besser ist, "grösser" oder "kleiner" zu verwenden
>(natürlich auch zusammen mit "gleich").

Wenn man die Std-Synthesetools (Xilinx/Altera) verwendet, schon. Dann
muss man nur noch das MSB-Bit (oder das nachfolgende Carry-Bit) auf
1 oder 0 testen.
Mit den Carry-Chains der Xilinx- (oder auch der Altera-)Chips kann
man auch auf Gleichheit testen, und das genauso schnell.
Nachteil: Die Schaltung muss man von Hand generieren.