asynchron / synchron

Eine beliebte Frage :-)

Nein, das Design ist dann nicht mehr synchron. Du kannst aber Deinen
halbierten Clock als Clock Enable Signal nutzen, mit dem Du dann
sozusagen den Originalclock maskierst, also:

if(reset = '0') then
  ...
elsif(clk'event and clk = '1') then
  if(clk_en = '1') then
    ...  -- hier arbeitet das Design mit "halbem" Clock
  end if;
end if;

Gruß
Ines

hi ines,

im endeffekt habe ich ähnlich gemeint, vielleicht aber falsch
ausgedrückt ;-)

bei mir sieht es folgendermaßen mit halbierter clock (hc_in) als
eingangstakt der folgenden einheiten und der in diesen einheiten aus
steuernden systemclock (clk):

..
signal hc_tmp1 : std_logic;
signal hc_tmp2 : std_logic;
..

if(reset = '0') then
  ..
  hc_tmp1 <= '0';
  hc_tmp2 <= '0';
  ..

elsif(clk'event and clk = '1') then
  hc_tmp1 <= hc_in;
  hc_tmp2 <= hc_tmp1;
  if (hc_tmp1=1 and hc_tmp2=0) then
    ...
  end if;
end if;

es wird die vorher halbierte clock auf den systemtakt
synchronisiert...oder?!?

Hallo Karl,

jetzt bin ich leicht verwirrt. Grafisch (Timing-Diagramm) dargestellt,
hast Du sowas beschrieben:
               _   _   _   _   
clk       _| |_| |_| |_| |_| |_| |_
            __     ___     __
hc_in     _|   |___|   |___|   |___
               ___     ___     __
hc_tmp1    |___|   |___|   |___|
            __     ___     __
hc_tmp2   _|   |___|   |___|   |___

AKTION:    ^       ^       ^

Du hättest also auch gleich schreiben können (vgl. meinen letzten
Beitrag):

if(reset = '0') then
  ...
elsif(clk'event and clk = '1') then
  if(hc_in = '0') then
    ...  -- hier arbeitet das Design mit "halbem" Clock
  end if;
end if;

Da Du hc_in aus clk abgeleitet hast (so habe ich es wenigstens
verstanden), musst Du das Signal nicht einsynchronisieren.

Gruß
Ines

hi ines,

alles ein wenig verwirrend... ;-)

ich habe die halbierte clock hc aus folgendem code erzeugt:

entity halber_takt is
 port ( clock1 : in std_logic;
        start : in std_logic;
        rst : in std_logic;
        hc : out std_logic);
end halber_takt;

architecture behav of halber_takt is
 signal hc_tmp : std_logic;

begin
 process(rst,clock1)
  variable start : boolean;
 begin
  if rst = '0' then
   hc_tmp <= '0';
  elsif rising_edge(clock1) then
   if start = '1' then
    hc_tmp <= not hc_tmp;
   end if;
   hc <= hc_tmp;
  end if;
 end process;
end behav;

dabei soll die variable start den beginn der halben taktgenerierung
kennzeichnen.

diesen halbierten takt hc möchte ich nun neben datensignalen, die auf
diesen halben takt adaptiert sind (1 bitausgabe => 1 hc periode), einem
weiteren modul als eingangssignal hinzuführen. die weitere
datenverarbeitung geschieht dann mit einem prozess, der neben der hohen
systemclock clk noch den reset rst in der sensitivitätsliste beinhaltet.

die vorher generierte hc wird dann über das folgende konstrukt auf den
systemtakt clk einsynchronisiert:

..
signal hc_tmp1 : std_logic;
signal hc_tmp2 : std_logic;
..

if(reset = '0') then
  ..
  hc_tmp1 <= '0';
  hc_tmp2 <= '0';
  ..

elsif(clk'event and clk = '1') then
  hc_tmp1 <= hc_in;
  hc_tmp2 <= hc_tmp1;
  if (hc_tmp1=1 and hc_tmp2=0) then
    ...
  end if;
end if;

und dann die weitere datenverarbeitung bishin zur Ausgabe vorgenommen.
Diese Ausgabe wird wieder

Meine Frage ist, ob nun das nachfolgende design, das mehrere module
enthält, wo der vorher generierte hc als zusätzliches eingangssignal
dient, synchron ist....

danke für deinen support!

sorry, hat sich ein kleiner tipp- und lesefehler eingeschlichen:

sollte natürlich folgendermaßen lautern:

entity halber_takt is
 port ( clock1 : in std_logic;
        start : in std_logic;
        rst : in std_logic;
        hc : out std_logic);
end halber_takt;

architecture behav of halber_takt is
 signal hc_tmp : std_logic;

begin
 process(rst,clock1)
  variable start_en : boolean;
 begin
  if rst = '0' then
   hc_tmp <= '0';
   start_en := false;
  elsif rising_edge(clock1) then
   if start = '1' then
    start_en := true;
   end if;
   if start_en then
    hc_tmp <= not hc_tmp;
   end if;
   hc <= hc_tmp;
  end if;
 end process;
end behav;

das startsignal ist ein einmaliges erergnis und deshalb als latch
realisiert....

OK, wenn ich es jetzt richtig verstanden habe, dann müsste es soweit
synchron sein!
Ich würde hc_in nur noch einmal öfter eintakten: hc_temp1 ist ja nur
ein einziges Mal eingetaktet - 2 bis 3mal wäre besser.

Gruß
Ines

vielen dank..!!
habe mir schon gedacht, dass es so synchron sein müsste, war mir aber
nicht ganz sicher..

werde mir deinen rat bezüglich des eintaktens mal überlgen. da ich aber
auch daten mit eingetakteten taktsignalen ausgeben muss, wird dadurch
ein weiteres delay resultieren.

danke für deinen support!!

lg
karl