MOORE / MEALY bei Synthese von "case"

[Chris (Gast)]

Nach Moore wird die abweisende eines Zustands 'Z1' durchlaufen, wenn die 
Übergangsbedingung zu 'Z2' erfüllt ist. Während dem Übergang, also 
zwischen Eintreten der Übergangsbedingung und rising_edge, erfolgt - 
entgegen Mealy - jedoch noch KEINE Ausgabe der Ausgangsvariablen des 
Folgezustandes, sondern erst dann wenn dieser erreicht wurde.
Ich habe zur Beschreibung einer Ablaufsteuerung die "case"-Funktion 
eingesetzt und muss nun für genau diese abweisende Kante von 'Z1' >> 
'Z2' auch eine Ausgangsbelegung angeben.
Entscheidet nun genau diese Bescheibung darüber welche Art von Automat 
synthetisiert wird? Welche Ausgangsbelegung ist zweckmäßig, zulässig, 
gebräuchlich, oder liegt ein genereller Denkfehler vor?
Danke Chris

[Chris (Gast)]

Anbei ein Beispiel als Ergänzung:


MOORE: ====================================
when Z1 =>
if(A='1') then
   y1<='1';
   zvneu<=Z1;
else y1<='1';  -- !
     zvneu<=Z2;
end if;

when Z2 =>
if(B='...') then
   y1<='0';
   zvneu<=...;
else ...

MEALY: ====================================
when Z1 =>
if(A='1') then
   y1<='1';
   zvneu<=Z1;
else y1<='0'; --!
     zvneu<=Z2;
end if;

when Z2 =>
if(B='...') then
   y1<='0';
   zvneu<=...;
else ...

[Chris (Gast)]

Bitte noch eine zusätzliche Frage mit selbem Bezug:
"case" wird parallel verarbeitet, "when" sequentiell.
Besteht innerhalb eines process mit case ein unterschied zwischen 
folgenden zwei Beschreibungsformen:

Zuerst Übergangsbedingung zum Folgezustand, danach innerhalb else die 
Ausgabe im aktuellen Zustand
when B =>    if (s4='1') then
                k2<='1';
    k3<='1';
    zvneu<=C;
             elsif (s6='1') then
                k2<='1';
    k3<='1';
    zvneu<=init;
             elsif (s1='1') then
                k2<='1';
                k3<='1';
    zvneu<=C;
             else k2<='1';
    k3<='1';
    zvneu<=B;
             end if;

Zuerst die Ausgabe im aktuellen Zustand, danach die Übergangsbedingung 
zum Folgezustand (üblich)
when B =>       k2<='1';
    k3<='1';
--    zvneu<=B;
             if (s4='1') then
                k2<='1';
    k3<='1';
    zvneu<=C;
             elsif (s6='1') then
                k2<='1';
    k3<='1';
    zvneu<=init;
             elsif (s1='1') then
                k2<='1';
                k3<='1';
    zvneu<=C;
             end if;

[FPGA-Küchle (Gast)]

Dein Problem ist nicht mealy oder moore sondern wann werden signale 
zugeweisen die in einem getakteten Prozess stehen und wann wenn sie 
ausserhalb des Prozess stehen. Beispiel.

Moore

process(clk_i)
begin
 if rising_edge(clk_i) then
  case state_q is
    when st1 =>
         if ein1_i = '1' then
         state_q <= st2;
        end if; 
    when st2 =>
 if ein2_i = '1' then
        state_q <= st1;
     end if; 
  end case;
 end if;
end process;

out1_o <= '1' when state_q = st1 else '0';
out2_o <= '1' when state_q = st2 else '0';

Mealy:

process(clk_i)
begin
 if rising_edge(clk_i) then
  case state_q is
    when st1 =>
        if ein1_i = '1' then
         state_q <= st2;
        end if; 
    when st2 =>
 if ein2_i = '1' then
         state_q <= st1;
     end if; 
  end case;
 end if;
end process;

out1_o <= '1' when state_q = st1 and ein1 /= '1'      or 
                   state_q = st2 and ein2_i = '1' else 
                   '0';

out2_o <= '1' when state_q = st2 and ein2   /= '1'      or 
                   state_q = st1 and ein1_i  = '1' else 
                   '0';

Bei beiden ist out1_o '1' when st1 aktiv ist und es wird '1' wenn der 
Übergang zu st1 ausgeführt wird. Bei st2 und Übergang zu st2 ist es 
'0'., egal ob mealy oder Moore.

Schreibst du die out -Zuweisungen in den Prozess werden diese erst zu 
nächsten clk_i Flanke gültig

Moore:

process(clk_i)
begin
 if rising_edge(clk_i) then
  case state_q is
    when st1 =>
          out1_oq <= '1';
          out2_oq <= '0';
        if ein1_i = '1' then
         state_q <= st2;
        end if; 

    when st2 =>
     out1_oq <= '0';
     out2_oq <= '1';   
    if ein2_i = '1' then
        state_q <= st1;
     end if; 
  end case;
 end if;
end process;

Hier wird bei der ersten Flanke in den nächsten State gewechselt, bei 
der zweiten wird entsprechend des States die Ausgangsgrößen gesetzt. 
Dafür werden deine ausgangssignale aus FF getrieben. Schreibst du sie 
ausserhalb des Prozesses wie oben. dann werden sie in der selben Periode 
wie der zustandwechsel zugeweisen (sind aber nicht mehr aus FF) 
getrieben. wenn man die ausgangssignale früher wechseln lassen will 
(also mit dem Zustandwechsel), schreibt man eine zweite Bedingung zum 
setzten der Ausgange, die Gleichzeitig mit dem Zustandwechsel aktiv 
wird:

Mealy

process(clk_i)
begin
 if rising_edge(clk_i) then
  case state_q is
    when st1 =>
          out1_oq <= '1';
          out2_oq <= '0';
        if ein1_i = '1' then
          out1_oq <= '0';
          out2_oq <= '1';
         state_q <= st2;
        end if; 
    when st2 =>
          out1_oq <= '0';
          out2_oq <= '1'; 
     if ein2_i = '1' then
        out1_oq <= '1';
         out2_oq <= '0';
         state_q <= st1;
     end if; 
  end case;
 end if;
end process;

Also wie oben gezeigt ist mealy-Moore bei kombinatorischen Ausgängen 
(ausserhalb Prozess) im zeitlichen verhalten gleich. bei Ausgängen aus 
FF (innerhalb prozess beschrieben, kommt bei Moore die AusgangsZuweisung 
ein takt später.
Schwierig zu beschreiben, das Problem ist.

[Chris (Gast)]

Gut zu vertehen, die Erklärung ist - 1000 Dank !