Dreieckgenerator programmieren

[VHDL Anfänger (Gast)]

Wie kann ich in VHDL einen Zähler programmieren, der von 0 hoch bis 255 
zählt, und dann von 255 wieder runter auf 0 und dann wieder hoch?
Also einen Dreieckgenerator.

[kurz (Gast)]

Echt gut: 2 Threads um andere für sich arbeiten zu lassen.

Also los.

[BorisM (Gast)]

Hi...
gidf !
Hast du schon mal die SUCHE benutzt?

Deine Frage ist sehr offen gestellt...
Willst du nur den Zählbefehl? -> a <= a + 1
Oder den kompletten VHDL-Code? -> hier z. B. ein "hoch"-Zähler

library IEEE;
use IEEE.std_logic_1164.all;
use work.std_arith.all;

entity COUNT is
  port( CLK, ENA : in std_logic;
        Q        : buffer std_logic_vector(3 downto 0);
        UEB      : out std_logic);
end COUNT;

architecture A1 of COUNT is
begin
   P1: process( CLK )
   begin
      if( CLK'event and CLK = '1' ) then
         if( ENA = '1' ) then
            Q <= Q + 1;
         end if;
      end if;
   end process;
   UEB <= '1' when Q = "1111" else '0';
end A1;

Hast du schon VHDL-Kentnisse?
Gruß Boris

[VHDL Anfänger (Gast)]

>Hast du schon VHDL-Kentnisse?

Gerade daran arbeite ich ja im Moment.

Ich würde es wahrscheinlich so programmieren:

  Triangle_counter: process(Takt)
  begin
    if (Takt ='1' and Takt'event) then
      case Counter_up_down is
        when 0  => Counter_up_down <= 1;
        when 1  => Counter_up_down <= 2;
        when 2  => Counter_up_down <= 3;



        when 253  => Counter_up_down <= 254;
        when 254  => Counter_up_down <= 255;
        when 255  => Counter_up_down <= 254;
        when 254  => Counter_up_down <= 253;
        when 253  => Counter_up_down <= 252;
        when 252  => Counter_up_down <= 251;
             end case;
    end if;
  end process Triangle_counter;

Das ist natürlich STUSS so, weil jede Zahl doppelt vorkommt.

Besser von 0 bis 255 hochzählen und dann von 511 auf 256 wieder 
runterzählen und das Bit8 einfach wegschmeissen.
Das kann man doch bestimmt auch anders schreiben, ohne das einem die 
Finger bluten?

[BorisM (Gast)]

Den VHDL_Code den ich weiter oben als Beispiel gepostet habe kannst du 
für den Anfang vielleicht erweitern. Du musst dir nur die Zählrichtung 
"merken" und immer vergleichen ob du bei 255 bzw. 0 angekommen bist und 
dann die Richtung ändern... Ist eine schöne Übung für den Anfang:)

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

So:

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.numeric_std.all;

signal counter : integer range 0 to 255 := 0;
signal up : std_logic := '1';

process begin
  wait until rising_edge(clk);
  if (up='1') then
     counter <= counter + 1;
     if counter=254 then  up <= '0';  end if;
  else
     counter <= counter - 1;
     if counter=1 then    up <= '1';  end if;
  end if;
end process;
ausgang <= std_logic_vector(to_unsigned(counter,8));

Als Tipp: kauf dir ein Buch, z.B. VHDL-Synthese von Reichardt/Schwarz

[BorisM (Gast)]

Es gibt auch schöne Lehrgänge beim PLC2 ;)

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

BorisM schrieb:
> Es gibt auch schöne Lehrgänge beim PLC2 ;)
ACK.
Da sollte man aber vorher ein/das Buch angesehen haben, sonst rauscht 
der Zug an einem vorbei...

[MaWin (Gast)]

> Das ist natürlich STUSS so, weil jede Zahl doppelt vorkommt.

Natürlich, der Zustand, ob man gerade aufwärts zählen sollte, oder 
abwärts, ist ein zusätzliches Bit, von dem aus man entscheiden muss, 
wass bei CLK passiert. Ohne dieses bit, ohne diesen Zustand, kann deine 
Schaltung nicht wissen, wo's lang geht.

Wo du dieses bit unterbringt, im count selber von dem dann eben 8 als 
Zähler genutzt werden und das neunte als Richtungszustandsbit, oder ob 
du es extra Wert nimmst, bleibt dir überlassen.

Und glücklicherweise kann VHDL Arithmetik, du brauchst nicht 512 when 
Fälle zu schreiben.

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

Der hier ist auch schön kompakt, er hat aber jeweils 2 Takte 0 und 255:

-- 0 und 255 sind jeweils 2 Takte lang
architecture Behavioral of CntTriangle is
signal cnt : unsigned (8 downto 0) := (others=>'0');
begin
   process begin
     wait until rising_edge(clk);
     cnt <= cnt + 1;
     if cnt(8)='1' then     
        counter <= std_logic_vector(    cnt(7 downto 0));
     else
        counter <= std_logic_vector(255-cnt(7 downto 0));
     end if;
   end process;
end Behavioral;

[GAST (Gast)]

ihr überbietet euch im formulieren der lösung, aber am ende kommt doch 
immer dasselbe raus.

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

@  GAST (Gast)
> aber am ende kommt doch immer dasselbe raus.
Sicher? Oder glaubst du das nur?