Ampelschaltung - Probleme bei der Synchronisation

[Christian K. (mortiferus)]

Hallo :)

wiedermal habe ich ein "kleines" Problem mit einer Hardwarebeschreibung. 
Diesmal soll eine kleine Ampelschaltung realisiert werden. Die Ampel 
soll zuerst nur die einzelnen Phasen durchlaufen, d.h.

1. Rot (Ausgangszustand) - dieser Zustand soll eine gewisse Zeit 
gehalten werden.

2. Rot/Gelb - dieser Zustand soll nur einen Clocktakt anhalten.

3. Grün - dieser Zustand soll eine gewisse Zeit gehalten werden.

4. Gelb - auch dieser Zustand soll etwas länger andauern, jedoch kürzer 
als die Grünphase.


Meine VHDL-Beschreibung:

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity Ampel is
  generic( k: positive := 6);
  port( clk: in std_logic;
               lights: out std_logic_vector(2 downto 0));
end Ampel;



architecture RTL of Ampel is

type state_type is (A, B, C, D);

signal state: state_type;

signal  New_Clock:    std_logic;
signal  Globalcount:  integer range 0 to 15;
signal   Clear: std_logic;

begin


Takt: process(clk) -- 16 MHz zu 1 Hz

variable counter: integer range 0 to 7999999 := 0;

begin

if rising_edge(clk) then
  if counter = 7999999 then
    New_Clock <= not New_Clock;
    counter := 0;
  else
    counter := counter + 1;
  end if;
end if;

end process Takt;




Zaehler: process(New_Clock,Clear) 

begin

if Clear = '1' then

  Globalcount <= '0';

elsif rising_edge(New_Clock) then
  
  Globalcount <= Globalcount + 1;

end if;

end process Zaehler;




FSM: process(Clk)

begin


if rising_edge(clk) then 

  case state is
  
    when A => if Globalcount = k then
         State <= B;
              else 
         State <= A;
              end if;
           
      when B => State <= C;
    
      when C =>  if Globalcount = k then
       State <= D;
           else
               State <= C;
           end if;
        
     when D => if Globalcount = 3 then
      State <= D;
         else 
      State <= A;
        end if;
       end case;
end if;
end process FSM;




Ampel_Zuweisung:
 Lights <=           "100" when (State = A) else
       "110" when (State = B) else
       "001" when (State = C) else
       "010" when (State = D) else
       "111";
       
       
Clear_Zuweisung: ?????



     
end RTL;

Wie man sieht habe ich ein Problem mit der Clear-Zuweisung, d.h. 
Globalcount soll immer wieder auf 0 zurückgesetzt werden, sobald man in 
einen neuen Zustand gelangt. Allerdings weiß ich einfach nicht, wie ich 
dies machen soll! Clear soll also immer zu Beginn eines Zustandes auf 
high gehen damit der Counter auf 0 gesetzt wird.

Oder ist das zu schwer gedacht? Seht ihr noch andere Probleme?
Vielen Dank für eure Mithilfe!

LG

[P. K. (pek)]

Was ich mal von Beginn weg ändern würde: Alles mit dem schnellen Clock 
takten (es gibt verschiedene Threads zum Thema hier drin).

Dann generierst Du beim Erreichen des jeweiligen Zählerstandes ein 
Triggersignal, dass Dir die zu implementierende Ampel-FSM einen Zustand 
weiter bringt.

Ein Clear brauchst Du nicht (schon gar kein asynchrones). Du setzt den 
Zähler mit demselben Triggersignal zurück, wie Du die Ampel-FSM 
weiterbringst.

[Morti (Gast)]

Vielen Dank für deine Antwort! Leider "hinke" ich deiner Ausführung noch 
etwas hinterher. Verstehe ich es richtig, dass du die 16 MHz-Clock 
generell anwenden willst, d.h. mein Taktprozess würde entfallen. Aber so 
etwas wie einen Counter muss ich doch integrieren, oder etwa nicht? Wie 
soll dieses Triggersignal aussehen, ich kann mir da gerade nicht 
wirklich etwas vorstellen? Wenn ich das richtig verstehe, müsste ich 
dann eine komplett andere FSM entwickeln ?

[Christian K. (mortiferus)]

Oder meinst du als Trigger vllt einen Counter, der bis zu einem gewissen 
Wert hochläuft. Hat er diesen erreicht, wird dann per if-Abfrage die FSM 
angesprochen. Neben der Aktivierung der FSM wird dann auch noch 
zeitgleich der Counter zurückgesetzt. Allerdings verstehe ich nicht, wie 
ich den Counter für die Zustandsdauer die Ampelphasen takten soll...mit 
16 MHz zählt der ja ein bissel schnell ;).

[Alexander F. (alexf91)]

Für den Zähler-Prozess würde ich keinen selbstgenerierten Takt verwenden 
sondern ein Clock-Enable Signal, welches du im Takt-Prozess jeweils für 
einen Takt setzt.
Etwa so:

Takt: process(clk) -- 16 MHz zu 1 Hz

variable counter: integer range 0 to 7999999 := 0;

begin

if rising_edge(clk) then
  CLK_EN <= '0';
  if counter = 7999999 then
    CLK_EN <= '1';
    counter := 0;
  else
    counter := counter + 1;
  end if;
end if;
end process Takt;

Zaehler: process(New_Clock,Clear) 
begin
   if rising_edge(clk) then
      if CLK_EN = '1' then
         Globalcount <= Globalcount + 1;
      end if;
   end if;

end process Zaehler;

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

Christian Klingler schrieb:
> Allerdings weiß ich einfach nicht, wie ich dies machen soll!
Der pragmatische Ansatz wäre, alles im selben Prozess zu machen:

Zaehler: process(New_Clock,Clear) 

begin

FSM: process(Clk) begin

if rising_edge(clk) then 

  if CLK_EN = '1' then -- siehe Code von Alexander 
     Globalcount <= Globalcount + 1;
  end if;

  case state is
    when A => if Globalcount = k then
                 State <= B;
              else 
                 State <= A;
              end if;
         Globalcount <= '0';           
      when B => State <= C;
    
      when C =>  if Globalcount = k then
                    State <= D;
                 else
                    State <= C;
                 end if;
                 Globalcount <= '0';        

      when D => if Globalcount = 3 then
                   State <= D;
                else 
                   State <= A;
                end if;
                Globalcount <= '0';        

       end case;
end if;
end process FSM;

BTW:
Wenn schon States, warum nicht gleich sprechende:

 Lights <=
       "100" when (State = gruen)   else
       "110" when (State = rotgelb) else
       "001" when (State = rot)     else
       "010" when (State = gelb)    else
       "111";

BTW2:
Wenn du schon alle States verwendet hast, dann brauchst du kein else 
mehr, denn es wird schlicht&einfach ignoriert, weil es ja keinen 
weiteren Zustand mehr gibt! Fazit:

 Lights <=
       "100" when (State = gruen)   else
       "110" when (State = rotgelb) else
       "001" when (State = rot)     else
       "010" ; --  State = gelb

Das ist so ähnlich, wie die when others Sache:
http://www.lothar-miller.de/s9y/categories/25-when-others

Christian Klingler schrieb:
> if rising_edge(clk) then
>   if counter = 7999999 then
>     New_Clock <= not New_Clock;
>     counter := 0;
>   else
>     counter := counter + 1;
>   end if;
> end if;
So werden keine Takte erzeugt! Neimals! Arbeite mit Clock-Enables! Wie 
es geht hat Alexander schon gezeigt, und du siehst es auch in meinen 
Blinklicht. Da wird im letzten Codebeispiel die Taktung mit Clock-Enable 
gezeigt:
http://www.lothar-miller.de/s9y/archives/80-Hello-World!.html

Und deine Ampel ist eigentlich (noch) nichts anderes als ein Lauflicht:
http://www.lothar-miller.de/s9y/archives/61-Lauflicht.html

[Christian K. (mortiferus)]

Erstmal vielen Dank an euch beide! Eure Vorschläge kann ich gut 
nachvollziehen und umsetzen. Mal schauen, ob es dann funktioniert!

[Christian K. (mortiferus)]

So ich habe die Hardwarebeschreibung angepasst:

Library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;

entity Ampel is
  
  port( clk: in std_logic;
      lights: out std_logic_vector(2 downto 0));
end Ampel;



architecture RTL of Ampel is

type state_type is (rot,rot_gelb,gruen,gelb);

signal state: state_type;


signal  Count:  integer range 0 to 15;
signal  CLK_EN: std_logic;



begin



Takt: process(clk)

variable counter: integer range 0 to 7999999 := 0;

begin

if rising_edge(clk) then
 
  if counter = 7999999 then
    CLK_EN <= '1';
    counter := 0;  
  else
       CLK_EN <= '0';
       counter := counter + 1;
  end if;
end if;

end process Takt;




FSM: process(clk)

begin


if rising_edge(clk) then 

  if CLK_EN = '1' then
    Count <= Count + 1;
  end if;
    

  case state is
  
    when rot => if Count = 5 then
           State <= rot_gelb;
       else 
           State <= rot;
          end if;
               Count <= 0;
           
      when rot_gelb => if Count = 2 then
         State <= gruen;
       else
         State <= rot_gelb;
           end if;
      Count <= 0;
    
    when gruen => if Count = 5 then
            State <= gelb;
          else
             State <= gruen;
          end if;
          Count <= 0;
        
    when gelb => if Count = 3 then
          State <= rot;
             else 
          State <= gelb;
              end if;
              Count <= 0;
  end case;


 

end if;
end process FSM;




Ampel_Zuweisung:
 Lights <= "100" when (State = rot) else
    "110" when (State = rot_gelb) else
    "001" when (State = gruen) else
            "010";
         
     
end RTL;

Allerdings erhalte ich nun die folgenden Warnungend es 
Synopsis-Compilers:

Pruning register CLK_EN
Register bit Count(0) is always 0, optimizing ...
|Register bit Count(1) is always 0, optimizing ...
Register bit Count(2) is always 0, optimizing ...
|Register bit Count(3) is always 0, optimizing ...
Found inferred clock Ampel|clk with period 5.00ns. Please declare a 
user-defined clock on object "p:clk"
WARNING - ngdbuild: logical net 'clk' has no load
WARNING - ngdbuild: DRC complete with 1 warnings


So, ich denke das Problem in diesem Fall ist die count <= 0 Zuweisung. 
Da ja alles parallel in der Hardware implementiert ist (oder?), ist 
count immer 0. Das heißt, das zurücksetzen des Zählers muss ich anders 
realisieren.

[Lattice User (Gast)]

Christian Klingler schrieb:
> So, ich denke das Problem in diesem Fall ist die count <= 0 Zuweisung.
> Da ja alles parallel in der Hardware implementiert ist (oder?), ist
> count immer 0.

Richtig, daran liegt es. Kleiner Fehler der Lothar unterlaufen ist, auch 
Chuck Norris ist nicht perfekt :-)

Christian Klingler schrieb:
> Das heißt, das zurücksetzen des Zählers muss ich anders
> realisieren.

Einfach nur jeweils im if-Zweig in dem auf den nächsten State gewechselt 
wird.

[Christian K. (mortiferus)]

Okay es funktioniert...Stufe 2 :) Wie schwierig ist es jetzt, das 
Durchlaufen einer Phase, mittels einem Taster auszulösen. Sprich, man 
drückt auf einen Taster und die Ampel beginnt aus dem Zustand Rot die 
verschiedenen anderen Zustände zu durchlaufen.

Die Schwierigkeit, die ich in diesem Fall sehe, ist die Erzeugung der 
Bedingung, d.h. es muss ein drücken des Schalters detektiert werden, 
vllt so: ?

Push: process (clk)

begin

if rising_edge(clk)
 
 if Button = 1 and Button_old = 0 then
      Button_Pushed <= '1';
 else 
      Button_Pushed <= '0';
 end if;

Button_old <= Button;

end if;
end process Push;

Und kann ich dann einfach noch eine If-Abfrage um count und um das 
case-Statement packen?

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

1. Externe Signale müssen einsynchronisiert/eingetaktet werden.
2. Taster und Schalter müssen entprellt werden.

[Christian K. (mortiferus)]

Ähm..erfülle ich denn nicht genau diese beiden Aspekte mit meiner Idee? 
Oder was genau meinst du mit "eintakten"?

Bezüglich der Entprellung...mal ganz naiv gefragt, entprelle ich den 
Schalter nicht, da ich eine Flankenerkennung durchführe?

[Christian K. (mortiferus)]

Okay....schon gut :) 
http://www.lothar-miller.de/s9y/categories/5-Entprellung

[Christian K. (mortiferus)]

@ Lothar

ich habe mir jetzt einfach mal dein Beispiel mit dem Schieberegister 
angeschaut, hätte aber noch zwei Fragen.

Mir ist auf der einen Seite die Funktion des Vorteilers noch nicht ganz 
klar, warum wird dieser gebraucht?

Und zweitens ...inputsr <= inputsr(2 downto 0) & input;

Wie interpretiert der Compiler das? Ist Input dann das LSB ?

Vielen Dank!


Edit: Ich habe auf dieser Seite ein Beispiel für die Softwareentprellung 
mittels reine Flankenerkennung gefunden, wie kann das dann 
funktionieren? Da ja zB eine steigende Flanke mehrmals vorliegt?!

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

Der Vorteiler wird gebraucht, weil sonst bei 50 MHz das Schieberegister 
in 80ns durch wäre. Ein Taster prellt sicher länger.

Der & Operator ist bei VHDL ein Verkettungsoperator, der input wird 
daher zum LSB.

[Falk B. (falk)]

Taktung FPGA/CPLD