Counter in 2 Process

[Max S. (schuby)]

Hallo, ich übe mich gerade in VHDL und habe ein Problem was ich nicht 
verstehe. Ich möchte einen count in 2 Process hoch zählen und da bekomme 
ich immer einen fehler. Könnte mir jmd einen Tipp geben wäre nett

 signal  count       : STD_LOGIC_VECTOR (3 downto 0):= "0000";


  Process (clk_q)  -- erster Clock
     begin
      bla bla bla then
            count<= count + '1';
     end if;  --End Clock Event
  end Process;


  Process (clk1)  -- 2ter Clock
     begin
      bla bla bla  then
            count<= count + '1';
     end if;  --End Clock Event
  end Process;

 Addr <= count;

mfg Schuby

[Pat A. (patamat)]

Max S. schrieb:
> Könnte mir jmd einen Tipp geben

1. Programmtags für Sourcecode verwenden ;-)

2. Für die allermeisten Fälle und für Anfänger insbesondere gilt: Ein 
Signal wird nur von einem Prozess getrieben!

Eine Lösungsmöglichkeit ist, dass (mindestens) ein Prozess ein Signal 
setzt, wenn der Counter inkrementiert werden soll und der andere Prozess 
(der den Counter hochzählt) dieses Signal zusätzlich zu seiner eigenen 
Logik auswertet, um den einen Zähler zu inkrementieren. Aber was ist, 
falls bei Prozesse gleichzeitig 'count' erhöhen wollen?

Oder den Zähler gleich in einen dritten Prozess auslagern.

Aber Vorsicht: Du hast zwei Taktdomänen! Da müssen die Signale aus der 
einen Taktdomäne erst in die andere einsynchronisiet werden, bevor sie 
verwendet werden können! Und bei Events (Signal ist nur ein Takt high), 
ist das nicht ganz trivial).

Aber erzähl doch mal, was Du wirklich machen willst und warum es zwei 
Taktdomänen sein müssen.

[Max S. (schuby)]

Hallo  Pat A, erstmal schönen Dank für deine Antwort.
Tja was habe ich vor ? Ich bin Rentner und fast 70 Jahre alt,
ich möchte mich beschäftigen.
Und nicht den ganzen Tag vor der Klotze verbringen. :-)

Vor habe ich im mom gar nichts, ich muss erst besser in VHDL werden.
Schaue mir jeden Tag Videos an und bin am üben.


mfg Schuby

[Pat A. (patamat)]

Sehr gut, sich mit VHDL zu beschäftigen. Dafür hast Du schon mal meinen 
Respekt!

VHDL ist schon recht anspruchsvoll. Da ist vieles anders, als man es vom 
'normalen Programmieren' gewohnt ist, das erfordert einiges Umdenken.

Eine sehr gute und hilfreiche Seite für den Einstieg ist von Lothar 
Miller (http://www.lothar-miller.de/s9y/); er ist sogar hier im Forum 
aktiv ;-)

[Max S. (schuby)]

Oh Danke das schaue ich mir gleich mal an.

Aber zu meiner Frage, ich bin am überlegen alles in einen Process
zu lassen und die beiden Clk über ein MUX zu schalten.

Ich habe doch noch das alte Spartan 3 von Digilent und da versuche
ich meine ersten Tests mit den beiden SRAM die unter der Platine sind.

1. Die SRAM schreiben möchte ich gerne mit einen hohen Clk.
2. Aber das Lesen möchte ich mit meinen Takt langsam so das ich auuch 
was sehe.

Das Spartan 3 Board habe ich mit einen XMega verbunden
8 Daten Bits und ein paar Steuerleitungen.

Na ja meine ersten Gehversuche :-) Aber es macht Spaß.

mfg Schuby

[Pat A. (patamat)]

Ah, ok - das ist schon fortgeschrittenes Level ;-)

Vielleicht noch ein Tipp dazu: zwei oder mehr Taktdomänen nimmt man nur, 
wenn's sich wirklich nicht vermeiden lässt - weil der Aufwand und die 
Fehlerträchtigkeit enorm ansteigt. Die Taktdomänen müssen unbedingt 
sauber getrennt bleiben und Signale, die in der anderen Taktdomäne 
verwendet werden, müssen umsynchronisiert werden - ansonsten sind 
Funktionsfehler garantiert!

Langsamere Takte in einem Single-Clock-Design generiert man sich am 
besten per heruntergeteiltem Clock-Enable (ungetestet, einfach mal 
runtergeschrieben):

constant ClockDivider: integer = 10;
signal clk_div: integer range 0 to ClockDivider-1;
signal clk_en: std_logic;

clk_div: process(reset, clk)
begin
    if (reset = '1') then
        clk_en  <= '0';
        clk_div <= ClockDivider-1;
    elsif rising_edge(clk) then
        clk_en <= '0';

        if clk_div = 0) then
            clk_en  <= '1';             -- clock enable für einen Takt
            clk_div <= ClockDivider-1;  -- Taktteiler neu starten
        else 
            clk_div <= clk_div - 1;
        end if;
    end if;
end process clk_div;

slow_clk_proc: process(reset, clk)
begin
    if (reset = '1') then
        -- ...
    elsif rising_edge(clk) then
        if (clk_en = '1') then
            -- jeden 10. Takt etwas ausführen
        end if;
    end if;
end process slow_clk_proc;

Aber auf gar keinen Fall einen Takt herunterteilen und diesen bzw. 
dieses Signal als neuen Takt verwenden (Stichwort 'gated clock'). Klingt 
zwar verlockend einfach, ist aber aber tatsächlich ziemlich 
problembehaftet und kann Fehler verursachen, die nur sporadisch 
auftreten können und schwer zu finden sind.

Weiterhin viel Spaß mit VHDL und FPGA - damit kann man echt tolle Sachen 
machen!

[Jens W. (jensw)]

Max S. schrieb:
> 1. Die SRAM schreiben möchte ich gerne mit einen hohen Clk.
> 2. Aber das Lesen möchte ich mit meinen Takt langsam so das ich auuch
> was sehe.

Hi Max S, das was du vor hast, habe ich bei mir schon am Laufen. Auch 
ein Xmega und ein FPGA. Ist zwar ein Spartan-6, aber das Prinzip bleibt 
gleich.
Ich empfehle dir alles im FPGA mit einem hohen Takt zu betreiben. Ganz 
egal ob du langsam lesen und schreiben willst, oder schnell.
Das Schreibsignal ist ja WE und zum Lesen nimmst du OE. Das ist dann vom 
CLK unabhängig.
Wenn du da den µC direkt mit dran hast, dann kannst du mit dem ja einen 
kleinen RAM Test laufen lassen und sehen ob das funktioniert.
Dazu schreibe ich Primzahlen und lese sie wieder aus. Damit kannst du 
schnell testen ob alles läuft.

Wenn du da noch ein paar Infos brauchst, dann melde dich gerne bei mir.

Viele Grüße

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

Max S. schrieb:
> ich übe mich gerade in VHDL
VHDL-Code bitte mit [vhdl] Tags umrahmen.

Max S. schrieb:
> Die SRAM schreiben möchte ich gerne mit einen hohen Clk.
> Aber das Lesen möchte ich mit meinen Takt langsam so das ich auuch was
> sehe.
Such mal nach "Postulate" hier im FPGA-Forum. Die tauchen dort auf, wo 
Anfänger typische Anfängerprobleme gemacht haben.

Aber generell gilt: nur 1 Takt pro Design. Das ist der Takt, der mit ca. 
50 MHz vom Taktpin des FPGAs kommt.

Und zum Thema "Clock-Enable sieh dir mal dort das Lauflicht an: dort 
wird in einem Prozess das langsame Clock-Enable erzeugt, aber das 
gesamte Design läuft mit hoher Taktfrequenz:
- http://www.lothar-miller.de/s9y/archives/61-Lauflicht.html

Später als Fortgeschrittener kannst du dann wenn nötig mit mehreren 
Taktdomänen anfangen, wenn du welche brauchst. Und bis dahin merkst du: 
das ist eigentlich gar nicht so oft der Fall.

[Max S. (schuby)]

Ich Danke euch allen für eure Hilfe.

Mit dem Clock habe ich verstanden.
Ich habe einen Link gefunden was ich gerade abarbeite. Sehr Interessant
https://github.com/chkrr00k/sram-controller/blob/master/sram.vhd

ahhh jetzt sehe ich es -->  [vhdl .]VHDL-Code[/vhdl .]


mfg Schuby