Ampelschaltung mit Coolrunner2

[Tobias R. (alpini)]

Hallo Jungs,

ich bin neu hier - weil ich keinen Plan von CPLD Programmierung hab, 
aber es nun brauche :-(

Folgendes:

Ich will mit einem Coolrunner2 eine Ampelschaltung machen.

Schritte bis jetzt:

- Takt mit vielen FF heruntergesetzt auf 1s
- Zähler mit Logikschaltung
- RS FF's zum setzten der Ampeln auf rot/grün!

Problem:
Bis zum Takt klappt alles, dann gibts probleme - ich glaub, mein Counter 
funktioniert nicht wirklich, welchen würdet ihr da nehmen? Wie 
beschalten?

Bitte um Hilfe, bin etwas ausgeschmissen...

Danke euch

Vielleich hat auch jemand schematics dazu! Wäre super

Ich kann auch einen Screenshot meines Schematic Plans einstellen wenns 
hilft?!

[Gina (Gast)]

Ja, mach mal.

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

Tobias Reinhard schrieb:
> mein Counter funktioniert nicht wirklich, welchen würdet ihr da nehmen?
Ich würde einen aus der VHDL-Kiste nehmen. Welchen hast du?

> Vielleich hat auch jemand schematics dazu!
Ach so. Vergiss das Gelumpe. Nur als Denkanstoß der 
Beitrag "kruder Fehler bei FPGA-Programmierung (ISE WEBpack-Schematic)"

Wenn du schon  was Neues lernst, dann so, dass du später auch was 
anfangen kannst damit: 
Beitrag "Re: Ampelsteuerung"

[Tobias R. (alpini)]

Bei mir siehts momentan so aus:

Siehe Anhang


Meint ihr ich solls lieber ohne Schematics machen und in VHDL 
programmieren?

[Falk B. (falk)]

JA!

Ein Zähler + Dekoder, mehr braucht man nicht!

[Tobias R. (alpini)]

Komm ich mit dem oben gezeigten Schematicdokument nicht hin?

Hab hald Schematics gewählt, da ich mir da wenigstens was drunter 
vorstellen kann...

Mit VHDL hab ich nämlich keine Erfahrung, das ist mein Problem...

Keiner unserer Prof's hat bis jetzt Erfahrungen mit VHDL gesammelt, 
deswegen ist das nun denkbar schwierig...

ISE Webpack macht mir auch schwierigkeiten ohne Ende - vllt. bin ich 
aber auch einfach zu blöd dafür...

In VHDL wäre das wahrscheinlich ein ziemlich kurzes Programm oder?

[Christoph Z. (christophz)]

Tobias Reinhard schrieb:
> In VHDL wäre das wahrscheinlich ein ziemlich kurzes Programm oder?

Ja.

Tobias Reinhard schrieb:
> Keiner unserer Prof's hat bis jetzt Erfahrungen mit VHDL gesammelt,
> deswegen ist das nun denkbar schwierig...

Dann such dir einen der damit Erfahrung hat in einem anderen 
Departement, Fachbereich, Standort etc.
Das Buzz-Word "interdisziplinäre Zusammenarbeit" kann da Wunder wirken 
;-)

[Falk B. (falk)]

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity ampel is
    Port ( clk : in  STD_LOGIC;
           red : out  STD_LOGIC;
           green : out  STD_LOGIC;
           yellow : out  STD_LOGIC);
end ampel;

architecture Behavioral of ampel is

signal prescaler : unsigned(16 downto 0);
signal cnt : unsigned(3 downto 0);
signal dec_out : unsigned(2 downto 0);
signal slow_clk : std_logic;

begin

-- prescaler

process(clk)
begin
  if rising_edge(clk) then
    prescaler <= prescaler +1;
  end if;
end process;

slow_clk <= prescaler(16);

-- state counter

process(slow_clk)
begin
  if rising_edge(slow_clk) then
    cnt <= cnt +1;
  end if;
end process;

-- output decoder

process(cnt)
  variable a: integer range 0 to 15;
begin
  a := to_integer(cnt);
  case a is
  --                           red 
  --                           |yellow
  --                           ||green
  --                           ||| 
    when  0     => dec_out <= "100";
    when  1     => dec_out <= "100";
    when  2     => dec_out <= "100";
    when  3     => dec_out <= "100";
    when  4     => dec_out <= "100";
    when  5     => dec_out <= "100";
    when  6     => dec_out <= "110";
    when  7     => dec_out <= "110";
    when  8     => dec_out <= "001";
    when  9     => dec_out <= "001";
    when 10     => dec_out <= "001";
    when 11     => dec_out <= "001";
    when 12     => dec_out <= "001";
    when 13     => dec_out <= "001";
    when 14     => dec_out <= "001";
    when 15     => dec_out <= "001";
    when others => dec_out <= "010";
  end case;
end process;

red <= dec_out(2);
yellow <= dec_out(1);
green <= dec_out(0);

end Behavioral;

[bko (Gast)]

und mit nur einem Takt für alle Flipflops:
http://www.mikrocontroller.net/articles/Taktung_FPGA/CPLD#Einleitung

....
signal prescaler : unsigned(16 downto 0);
signal incscaler : unsigned(17 downto 0);
signal cnt : unsigned(3 downto 0) := "0000";
signal dec_out : unsigned(2 downto 0);
signal slow_clk : std_logic;

begin

-- prescaler

incscaler <=  '0' & prescaler +1;

process(clk)
begin
  if rising_edge(clk) then
    prescaler <= incscaler(16 downto 0);
  end if;
end process;

slow_clk <= incscaler(17);

-- state counter

process(clk) --(slow_clk)
begin
  if rising_edge(clk) then --(slow_clk) then
    if (slow_clk = '1') then
        cnt <= cnt +1;
    end if;    
  end if;
end process;

-- output decoder
 ...

[ralfi (Gast)]

Danke für eure Hilfe...

Meine Taktfrequenz ist 8MHz, die müsst ich auch noch irgendwie bremsen 
auf 1 Hz oder so

Macht man das am besten mit einem clock enable?

[fpga anfänger (Gast)]

> -- prescaler
>
> process(clk)
> begin
>   if rising_edge(clk) then
>     prescaler <= prescaler +1;
>   end if;
> end process;
>
> slow_clk <= prescaler(16);
>
> -- state counter
>
> process(slow_clk)
> begin
>   if rising_edge(slow_clk) then
>     cnt <= cnt +1;
>   end if;
> end process;
>
> -- output decoder

mal ne Frage an die Profis ... ich habe mal gehört so was ist unsauber, 
da man keinen rising_edge-"Befehl" auf ein anderes Signal als clk 
donnern sollte, da die clockplanes sonst nicht sauber sind.

ist es nicht besser zu schreiben..

process(slow_clk,clk)
begin
  if rising_edge(clk) then
    if slow_clk == '1' then... usw.

Ich habe auch noch nicht verstanden was diese Prozesse mit Sensitivliste 
sollen. Klar funktioniert das und ist im Standard definiert aber mit 
wait until, ist es meiner Meinung nach wesendlich sauberer, da nichts 
vergessen werden kann (Sensitivliste) und dann nur im Simulator 
funktioniert.

Bitte mal statemants abdrücken :-D

@TO
slow_clk ist ein clock enable.

[PittyJ (Gast)]

Ich nehme nur rising_edge auf clock und nichts anderes.
Ein rising_edge auf slow_clock läuft ja nicht unbedingt parallel, 
sondern kann zeitliche Abweichungen haben. D.h. dieser Process arbeitet 
'asynchron'.
Spätestens beim Austausch von Signalen könnte es zu Problemen kommen.

So habe ich es jedenfalls verstanden, und arbeite mit dieser 
Einschränkung ganz gut.

[Christoph Z. (christophz)]

fpga anfänger schrieb:
> mal ne Frage an die Profis ... ich habe mal gehört so was ist unsauber,
> da man keinen rising_edge-"Befehl" auf ein anderes Signal als clk
> donnern sollte, da die clockplanes sonst nicht sauber sind.

slow_clk IST ein Taktsignal (wie richtig geschrieben wurde, muss man 
beachten, dass slow_clk asynchron zu clk ist), von daher ist das schon 
sauber. Die Frage ist, ob man wirklich zwei Takte haben muss für diese 
simple Aufgabe. Deine Kritik kann angebracht sein.

Wenn für das ganze Design genau einmal dieser Clock-Prescaler vorhanden 
ist und alles andere dann mit slow_clk arbeitet, ist das aus meiner 
Sicht sauber (könnte ja z. B. auch umgekehrt sein, Eingangstakt mit 
einer PLL zuerst mal schneller machen). In diesem Fall würde ich aber 
die Namen anders wählen, damit der intern verwendete Takt "clk" heisst.


Wenn aber das Design normalerweise mit clk als Takt läuft und irgendwo 
lokal dieser slow_clk generiert wird, dann ist das unsauber und sollte 
wie von dir vorgeschlagen synchron mit einem Clock Enable realisiert 
werden (beim synchronen Prozess gehört das Clock Enable Signal NICHT in 
die Sensitiviti Liste)

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

fpga anfänger schrieb:
> mal ne Frage an die Profis ... ich habe mal gehört so was ist unsauber,
> da man keinen rising_edge-"Befehl" auf ein anderes Signal als clk
> donnern sollte, da die clockplanes sonst nicht sauber sind.
Na gut, man muss da ein wenig differenzieren. Du hast ein altes CPLD, da 
gibt es gar keine Taktnetze und Clockmanager. Also treffen da einige der 
Fausformeln für FPGAs nicht zu. Nur: wenn man sich schon am Anfang so 
einen murksigen Beschreibungsstil angewöhnt, dann denkt man später beim 
Umstieg auf ein FPGA nicht mehr drüber nach...

> ist es nicht besser zu schreiben..
> process(slow_clk,clk)
> begin  if rising_edge(clk) then
>     if slow_clk == '1' then... usw.
Doch, aber es reicht hier, wenn clk in der Sensitivliste steht. Einfach 
mal kurz drüber nachdenken...

> Ich habe auch noch nicht verstanden was diese Prozesse mit Sensitivliste
> sollen. Klar funktioniert das und ist im Standard definiert aber mit
> wait until, ist es meiner Meinung nach wesendlich sauberer, da nichts
> vergessen werden kann (Sensitivliste) und dann nur im Simulator
> funktioniert.
Meine ich auch... ;-)
Aber man muss schon zugeben, dass manche Logik/Kombinatorik mit einem 
Prozess einfach schöner lesbar ist.

> slow_clk ist ein clock enable.

Tobias Reinhard schrieb:
> In VHDL wäre das wahrscheinlich ein ziemlich kurzes Programm oder?
Nein. Es wäre in VHDL kein Programm sondern eine Beschreibung! Denn 
es heißt nicht umsonst VHDL und nicht VHPL!

Christoph Z. schrieb:
> slow_clk IST ein Taktsignal (wie richtig geschrieben wurde, muss man
> beachten, dass slow_clk asynchron zu clk ist), von daher ist das schon
> sauber.
Aber WIE dieser Takt gewonnen wurde ist auf einem FPGA insdiskutabel und 
schlampig.

[Falk B. (falk)]

@ ralfi (Gast)

>Meine Taktfrequenz ist 8MHz, die müsst ich auch noch irgendwie bremsen
>auf 1 Hz oder so

Dann musst du den Prescaler anpassen. Das ist eine Aufgabe för den 
Schööööler.

>Macht man das am besten mit einem clock enable?

Das wurde schon mehrfach gesagt, du must schon mal lesen und nachdenken. 
Das Forum ist kein Hörbuch.

Beitrag "Re: Ampelschaltung mit Coolrunner2"

[fpga-anfänger (Gast)]

Lothar Miller schrieb:

> Meine ich auch... ;-)
> Aber man muss schon zugeben, dass manche Logik/Kombinatorik mit einem
> Prozess einfach schöner lesbar ist.

Okay ich korrigiere meine Aussage ... Bei getakteten Prozessen verwende 
ich keine Sensitivlisten.

Das nur das clk in der Sensitivliste stehen muss, habe ich verstanden 
... Danke