Ablauf von einer Programmänderung mit Quartus2

[Peter B. (funkheld)]

Hallo, guten Tag.
Ich habe jetzt hier eine Demo wo die LED0 und LED7 blinkt.
Dieses liegt als Projekt vor und läuft auch.

Nun habe ich im Quartustextfenster dieses geändert und neu 
abgespeichert:
count <= count + "0000000000000000000000001";
zu
count <= count + "0000000000000000000011111";

Anschließend compiliert und die neue SOF übertragen, aber die 
Blinkfrequenz hat sich nicht geändert. Es wurde nicht übernommen?
Muß man ein neues Projekt erzeugen?

Danke.
Gruss
---------------------------------------------------
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;

entity blink is
    port (
        clk: in STD_LOGIC;
        led: out STD_LOGIC_VECTOR (1 downto 0)
    );
end blink;

architecture blink_arch of blink is
signal state : STD_LOGIC_VECTOR(1 downto 0);
signal terminal_count : STD_LOGIC;
signal count : STD_LOGIC_VECTOR(24 downto 0);
begin

led <= state; -- led kann man nicht lesen, also verwenden wir intern ein 
anderes signal

process (clk) -- Ein Puls
begin
  if rising_edge(clk) then
     count <= count + "0000000000000000000000001";
     if (count = "1111111111111111111111111") then
        terminal_count <= '1';
     else
       terminal_count <= '0';
     end if;
  end if;
end process;

process (clk)
begin
  if rising_edge(clk) then
    if terminal_count = '1' then
      case state is
        when "01" =>
           state <= "10";
        when "10" =>
           state <= "01";
        when others =>
           state <= "01";
        end case;
    end if;
  end if;
end process;

end blink_arch;
------------------------------------

[Lisa (Gast)]

Hallo Peter

Dein count signal wird nie auf 0 gesetzt (z.B. beim Reset am Start) und 
ist somit undefiniert. Daher wäre es Zufall, wenn count genau 
"1111111111111111111111111" erreichen würde.

[Googler (Gast)]

Peter Bierbach schrieb:
> count <= count + "0000000000000000000000001";
>      if (count = "1111111111111111111111111") then

wenn du + 0000000000000000000011111
rechnest kannst du nicht auf 1111111111111111111111111 kommen

ändere lieber die Abfrage

[Lisa (Gast)]

Googler schrieb:
> wenn du + 0000000000000000000011111
> rechnest kannst du nicht auf 1111111111111111111111111 kommen

Wieso nicht?

[Duke Scarring (Gast)]

Peter Bierbach schrieb:
> use IEEE.std_logic_unsigned.all;
Verwende lieber ieee.numeric_std.all
Siehe: Beitrag "IEEE.STD_LOGIC_ARITH.ALL obsolete"

Dann kannst Du die Addition auch lesbarer gestalten:

library ieee;
use ieee.std_logic_1164.all;

entity blink_testbench is
end entity blink_testbench;


architecture testbench of blink_testbench is

    component blink is
        port (
            clk : in  std_logic;
            led : out std_logic_vector (1 downto 0)
            );
    end component blink;


    constant tb_clk_period : time := (1 sec) / 50_000_000;

    signal tb_clk : std_logic := '0';
    signal tb_led : std_logic_vector (1 downto 0);

begin
    
    tb_clk <= not tb_clk after tb_clk_period / 2;

    dut : blink
        port map (
            clk => tb_clk,              -- : in  std_logic;
            led => tb_led               -- : out std_logic_vector (1 downto 0)
            );

end architecture testbench;





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

entity blink is
    port (
        clk : in  std_logic;
        led : out std_logic_vector (1 downto 0)
        );
end entity blink;

architecture blink_arch of blink is

    signal state          : std_logic_vector(1 downto 0);
    signal terminal_count : std_logic;
    signal count          : unsigned(24 downto 0) := (others => '0');  -- mit 0 initialisieren

begin

    led <= state;  -- led kann man nicht lesen, also verwenden wir intern ein anderes signal

    process                             -- Ein Puls
    begin
        wait until rising_edge(clk);
        count <= count + 1;
        if count > 30000000 then
            terminal_count <= '1';
            count          <= (others => '0');
        else
            terminal_count <= '0';
        end if;
    end process;

    process
    begin
        wait until rising_edge(clk);

        if terminal_count = '1' then
            case state is
                when "01" =>
                    state <= "10";
                when "10" =>
                    state <= "01";
                when others =>
                    state <= "01";
            end case;
        end if;

    end process;

end architecture blink_arch;

Ich hab gleich mal eine Stimulitestbench dazugebaut, damit kann man 
vorher testen, ob der Algorithmus passt.

Duke

[Josef G. (bome)]

Peter Bierbach schrieb:

> signal count : STD_LOGIC_VECTOR(24 downto 0);

> count <= count + "0000000000000000000000001";

Zwischenfrage: Seit wann kann man mit std_logic_vector ohne
vorherige Umwandlung nach unsigned Arithmetik betreiben?

[Googler (Gast)]

Lisa schrieb:
> Googler schrieb:
>> wenn du + 0000000000000000000011111
>> rechnest kannst du nicht auf 1111111111111111111111111 kommen
>
> Wieso nicht?

OK. war Unsinn.
Die 1 am Ende kumuliert natürlich genauso auf 1111111111111111111111111

Schäm.

[Peter B. (funkheld)]

Hallo, vielen Dank für die Hilfe.

-----------------------
Ich hab gleich mal eine Stimulitestbench dazugebaut, damit kann man
vorher testen, ob der Algorithmus passt.
------------------------

Ist diese Simulation auch ein Programm für das compilieren zu einer SOF 
oder nur für den Simulator?

Wie startet man bitte das Simulationsprogramm in Quartus?

Gruss

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

Josef G. schrieb:
> Zwischenfrage: Seit wann kann man mit std_logic_vector ohne
> vorherige Umwandlung nach unsigned Arithmetik betreiben?
Das geht, wenn man die alten Synopsys Libs verwendet:
Peter Bierbach schrieb:
> use IEEE.std_logic_unsigned.all;
Aber das ist ein Beschreibungsstil des letzten Jahrausends!!

Heute verwendet man die herstellerunabhängige numeric_std:
http://www.lothar-miller.de/s9y/categories/16-Numeric_Std

Peter Bierbach schrieb:
> Ist diese Simulation auch ein Programm
Nein. Das ist KEIN Programm, weil VHDL nämlich eine "hardware 
DESCRIPTION language" und keine "hardware PROGRAMMING language" ist. Und 
weil VHDL eben nicht VHPL heißt. Du machst dich sachte lächerlich, wenn 
du beharrlich bei VHDL Code von einem Programm sprichst.