prozesse Verbinden

[Markus (Gast)]

Hallo!

ich habe eine Frage wie ich 2 Prozesse verbinde. Ich habe konkret einen 
um aus einem quadratur Signal clk und dir zu machen:

entity quadrature_encoder is
    Port ( isl_clk : in  STD_LOGIC;
           isl_a : in  STD_LOGIC;
           isl_b : in  STD_LOGIC;
           osl_cout_en : out  STD_LOGIC;
           osl_count_dir : out  STD_LOGIC);
end quadrature_encoder;


Wenn ich damit nun einen Counting Prozess takten möchte, wie mache ich 
das dann mit dem isl_clk. Würde der Counter auch als Eingang den 
Systemtakt haben und mit wait until rising_edge synchron gemacht, oder 
kann ich mit dem count_en und dir direkt zählen?

Ich bin wie ihr merkt gerade etwas verwirrt. Ich habe Sorge, dass 
unnötige clocks in der Sensitivitätsliste mir alles 'verranzen'

Ich bedanke mich schon mal.

[berndl (Gast)]

haeh!?!?

du weisst aber schon in etwa wie HW funktioniert?

Deine Entity/Komponente hat einen Takt-Eingang (isl_clk), was du in der 
Komponente damit machst ist dann erstmal dein Problem.

Und was du mit den Outputs deiner Komponente (innerhalb der Komponente) 
so alles anstellst, woher sollen wir das wissen?

Und
> Würde der Counter auch als Eingang den
> Systemtakt haben und mit wait until rising_edge synchron gemacht, oder
> kann ich mit dem count_en und dir direkt zählen?

??? Woher sollen wir das wissen? Und ehrlich gesagt habe ich deine Frage 
noch nichtmal verstanden...

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

Markus schrieb:
> Ich habe Sorge, dass unnötige clocks in der Sensitivitätsliste mir
> alles 'verranzen'
Dem Synthesizer ist die Sensitivliste eh' vollkommen schnurz, und die 
Simulation stört sich nicht an zu vielen Signalen. Sie ist nur dann 
flasch, wenn relevante signale fehlen.

Aber idR. ist es vollkommen simpel: in einem getakteten Prozess ist nur 
ein einziger Takt (nämlich der, der zumindest in Anfängerprojekten in 
ALLEN anderen Prozessen auch drin steht) und schlimmstenfalls noch ein 
asynchroner Reset. Das wars. Wenn da mehr drin steht, dann ist das in 
99,99% aller Fälle ein Fehler.

> Ich habe konkret einen um aus einem quadratur Signal clk und dir zu
> machen:
> entity quadrature_encoder is
Das ist KEIN Prozess, sondern ein Modul, das du als Komponente 
irgendwo einbinden kannst.

Mein Tipp: fang mal ganz klein an. Mit einem BLinklicht, dann mit einem 
Lauflicht. Und immer vorher simulieren!
http://www.lothar-miller.de/s9y/archives/80-Hello-World!.html

[Markus (Gast)]

Hallo!

Danke erst mal und tschuldigung, dass ich jetzt erst von mir hören 
lasse. War krank und bin einige Tage durchgecheckt worden.

Ja, da ist mir einiges begrifflich durcheinander gekommen. :-( Lothar 
Miller hat es richtig gestellt. Meinte ich allerdings auch. An berndl 
kann man sehen wie ein Thread schon wegen solcher Fehler einen miesen 
Start bekommt und zum scheitern verurteilt ist.

Also meine Frage ist, wie ich sinnig mit dem Modul zum Encoder einen 
Zähler laufen lassen würde:

----------------------------------------------------------
--pkg_bin2bcd
----------------------------------------------------------
--PACKAGE
----------------------------------------------------------
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.NUMERIC_STD.ALL;

package pkg_quadrature_encoder is
  component quadrature_encoder is
    Port ( isl_clk : in  STD_LOGIC;
           isl_a : in  STD_LOGIC;
           isl_b : in  STD_LOGIC;
           osl_cout_en : out  STD_LOGIC;
           osl_count_dir : out  STD_LOGIC);
  end component quadrature_encoder;
end pkg_quadrature_encoder;
----------------------------------------------------------
--pkg_bin2bcd
----------------------------------------------------------
--ENTITY
----------------------------------------------------------
LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.NUMERIC_STD.ALL;
USE pkg_quadrature_encoder.all;

entity quadrature_encoder is
    Port ( isl_clk : in  STD_LOGIC;
           isl_a : in  STD_LOGIC;
           isl_b : in  STD_LOGIC;
           osl_cout_en : out  STD_LOGIC;
           osl_count_dir : out  STD_LOGIC);
end quadrature_encoder;

architecture Behavioral of quadrature_encoder is
signal slv_a_reg : std_logic_vector(2 downto 0);
signal slv_b_reg : std_logic_vector(2 downto 0);
begin

process begin
  wait until rising_edge(isl_clk);
  slv_a_reg(2 downto 1) <= slv_a_reg(1 downto 0);
  slv_b_reg(2 downto 1) <= slv_b_reg(1 downto 0);
  slv_a_reg(0) <= isl_a;
  slv_b_reg(0) <= isl_b;
end process;

osl_cout_en   <= (slv_a_reg(2) xor slv_a_reg(1)) xor (slv_b_reg(2) xor slv_b_reg(1));
osl_count_dir <= slv_a_reg(1) xor slv_b_reg(2);

end Behavioral;

Version a)
Bekommt ein Counter dann sinnvollerweise z.B. osl_cout_en und 
osl_cout_dir als Eingangssignale und fragt die ala

process begin
 if rising_edge(osl_cout_en) then
  if osl_cout_dir = '1' then
   counter_value <= counter_value + 1;
  else
   counter_value <= counter_value - 1;
  end if;
 end if;
end process;

oder
Version b) isl_clk ist auch ein Eingangssignal und ich mache

process begin
  wait until rising_edge(isl_clk);

  if osl_cout_en = 1 and osl_cout_dir = 1 then
    counter_value <= counter_value + 1;
  else if osl_cout_en = 1 and osl_cout_dir = 1 then
    counter_value <= counter_value - 1;
  end if;
end process;

Bei dieser Version habe ich eine gravierende Verständnishürde! Bei einem 
Takt erzeugt das Modul für die quadratur-dekodierung als Kombinatorik 
die Signale osl_cout_en und osl_cout_dir. Aber bei dem selben Takt soll 
dann das Ergebnis schon bei einem anderen Prozess in dem anderen Modul 
counter ausgewertet werden können....aber das geht doch gar nicht. Bei 
dem Takt müssen doch erst Gatter laufen und das Signal über Leitungen 
flitzen!?

Ich HOFFE sehr ihr lest noch mal meinen korrigierten Thread und könnt 
mir helfen!


Allerherzlichen Dank

[Achim S. (Gast)]

Markus schrieb:
> Bei dieser Version habe ich eine gravierende Verständnishürde! Bei einem
> Takt erzeugt das Modul für die quadratur-dekodierung als Kombinatorik
> die Signale osl_cout_en und osl_cout_dir. Aber bei dem selben Takt soll
> dann das Ergebnis schon bei einem anderen Prozess in dem anderen Modul
> counter ausgewertet werden können....aber das geht doch gar nicht. Bei
> dem Takt müs

Die Steuersignale werden im Takt n erzeugt und im Takt n+1 ausgewertet. 
Wenn cout_en auf 1 geht, dann wird genau 1 Takt später der Zähler 
hochgezählt (oder runtergezählt). So läuft das immer bei getakteter 
Logik.

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

Markus schrieb:
> if rising_edge(osl_cout_en)
Was war denn an dem Satz "nur 1 Takt im gesamten Design!" unverständlich 
formuliert?

Markus schrieb:
> Aber bei dem selben Takt soll dann das Ergebnis schon bei einem anderen
> Prozess in dem anderen Modul counter ausgewertet werden können....
Warum muss diese Verarbeitung im selben Takt sein? Reicht es nicht 
aus, wenn der Zähler mit 20ns Verzögerung (bei 50MHz Taktfrequenz) 
reagiert?

EDIT:
Ich habe mir das nochmal angeschaut und komme nach entfernen einiger 
Syntax-Fehler (die den Verdacht naheliegen, dass du diesen Code noch nie 
getestet hast) und einer kleinen Strukturumstelleung (wozu den Decoder 
in ein Package packen) zu angehängtem Ergebnis: sieht brauchbar aus. 
Sieh dir einfach mal die Wavefrom der Testbench an...