FPGA Diode ansteuern

Ich nehme mal an, deine Diode hat je eine Kathode+Anode pro Farbkanal. 
Einfach rausfinden per Durchklingeln mit 2-3V DC kurz am Pin.

FPGA-seitig müsstest du 'nen Taktteiler bauen. Also einen Zähler mit n 
Bit, der bei deinem Grundtakt alle soundsoviel Mikrosekunden mit dem MSB 
überläuft (bei Überlauf auf 0 rücksetzen). Damit hast du erstmal ein 
Timing.

Damit 'ne PWM draus wird, müsstest du noch ein Tastverhältnis definieren 
können. Du schleifst also noch einen Vektor rein mit der Breite deines 
Zählers, der Werte zwischen 0 und 2^Zählerbreite enthalten kann. Beim 
Erreichen des Zählerstands togglest du einfach deinen Ausgangspin.

Das instanziierst du 3 mal, also einmal pro Kanal und das müsste es 
sein.

Gibt aber noch andere Ansätze, schau dir mal das Datenblatt der AVRs an, 
dort werden die Timer sehr gut und ausführlich dokumentiert.

Also einen Schaltplan habe ich nicht vor mir. Ich habe das User Manual 
zur Hand und habe daraus die Ausgänge rausgelesen sowie den clock. Unser 
Prof hat uns nahe gelegt uns an diesem Zustandsautomaten zu halten. Den 
kann ich natürlich so nicht übernehmen. Aber das mit den Zuständen kommt 
mir natürlich sehr bekannt vor. Den Code der uns empfohlen wurde ist als 
Datei angehängt. Und nein, das ist eine einzige Diode, die 3 Farben 
hat...insgesamt sind dort 4 Beinchen angebracht..einmal minus und dann 
die anderen drei Farben halt. Das soll nicht als PWM Signal realisiert 
werden.

Hmm, na gut, brauchst also keine PWM, sollst nur Farben togglen.

Dein Codebeispiel taugt für die Simulation, ist aber nicht wirklich 
synthetisierbar (wait-Anweisungen). Anstelle der Wait-Anweisung müsstest 
du halt z.B. eben so einen Zähler bauen, der jede Sekunde überläuft. 
Beim Überlauf wechselst läufst du dann deine Statemachine ab.

Also: Zähler von 27 Bit Breite bauen und wenn das MSB '1' wird, 
Statemachine durchlaufen und Zähler wieder zurücksetzen.

Kannst also einiges weiterverwenden von deinem Codebeispiel. Nicht 
vergessen, deine Constraints (UCF) richtig zu setzen, damit du mit den 
richtigen Pegeln arbeitetest. Das kannst du aber schon rausfinden, bevor 
du 'nen Zähler implementierst, indem du einfach die jeweiligen Ausgänge 
auf '1' in deiner Verhaltensbeschreibung legst.

Gut alles klar.

Aber wie genau funktioniert dieser Zähler und warum muss der eine Größe 
von 27 Bit haben? Könnte ich nicht einfach anhand des Clocks bei 
fallender oder steigender Flanke meine Zustände durchlaufen? Als ich das 
mit dem Mikrokontroller realisiert habe, habe ich 3 Eingänge und 3 
Ausgänge benutzt und für die die Zustände - enum -. Durch mein Delay 
konnte ich dann immer eine Zeit deklarieren für die Verzögerung. Mir ist 
schon klar, dass ein FPGA anders arbeitet. Aber ist die Umsezung so 
anders als beim Mikrocontroller? Ich habe zur Zeit so meine 
Schwierigkeiten beim Umdenken. Aber danke für die schneller Antworten. 
=)

Ja das ist eine gute Frage. Ich hab halt selber bis jetzt nur mit c++ 
programmiert und die Umstellung fällt mir nicht leicht. Der Code den ich 
vorhin mit angefügt hatte ist sogar aus dem Buch ;)! Hab das hier vor 
meiner Nase liegen. Ich danke für die hilfreichen Antworten...mal sehen 
was sich so machen lässt!

Thomas K. schrieb:
> Gut alles klar.
>
> Aber wie genau funktioniert dieser Zähler und warum muss der eine Größe
> von 27 Bit haben?

Na überleg doch mal wie viele Zyklen du brauchst, um bei 50Mhz eine 
Sekunde zu erreichen. Die 27 ist über den Daumen gepeilt der Logarithmus 
Dualis zur 50e6. Soll heißen, läuft das MSB über, isses knapp ne 
Sekunde.

Setz dich früh damit auseinander, wie du korrekte Timings erhalten 
kannst und Zähler implementierst. Du musst dafür schon ein einfaches 
Addierwerk implementieren und taktsynchron sein. Wenn du das hast, hast 
du die halbe Miete.

Auf Lothars Seite findest du sehr gute Anregungen, wie das richtig 
gemacht wird -> unbedingt anschauen.

> Könnte ich nicht einfach anhand des Clocks bei
> fallender oder steigender Flanke meine Zustände durchlaufen?

Überleg doch mal, was das bewirkt, wenn du in jedem Takt deinen Zustand 
wechselst. Welche Farbe denkst du denn, kommt dabei raus, wenn du mit 
der Trägheit des menschlichen Sehsystems auf die Diode guckst?

Naja mit jedem Takt wechsel ich natürlich meinen Zustand und mische 
entweder eine Farbe rein oder auch raus.

Thomas K. schrieb:
> Naja mit jedem Takt wechsel ich natürlich meinen Zustand und
> mische
> entweder eine Farbe rein oder auch raus.

Wenn du einen externen Takt von 1Hz hast, mag das so funktionieren. 
Nimmst du aber die 50Mhz vom Board, wird das nüscht. Dann musst du die 
eben runterteilen, bis du eine Frequenz erhältst, die halbwegs sinnvoll 
erscheint.

Nix anderes macht ein Zähler, der bei jeder steigenden Flanke 
inkrementiert wird - jede Bitstelle wechselt also ihren Zustand mit der 
jeweils halben Original-Taktfrequenz. Das LSB ist also 50Mhz, das Bit 1 
25Mhz, Bit 2 12.5Mhz usw. usf.

Möchtest du also keine weiß leuchtende RGB-LED, sondern ein etwas 
schmalbandigeres Spektrum haben - so lange warten, bis dein Auge die 
Farbe wahrnehmen kann.

Btw: wenn du in deinem Mikrocontroller 'ne Sleep-Routine (und keinen 
Interrupt) genommen hast, kann die auch so implementiert sein, dass sie 
den von dir angegebenen Zeitraum einfach No-Ops ausführt und damit den 
Befehlszähler vom uC belastet. Vielleicht hilft dir das, ein wenig den 
Zugang zu finden.

...und den kombinatorisch runtergeteilten Takt (Zähler) nicht direkt als 
Taktquelle verwenden, sondern als Clock Enable. Ist zwar implizit in 
Lothars Aussage schon enthalten:

Lothar M. schrieb:
> Ein Design hat genau 1 Takt, der immer auf die selbe Flanke reagiert
> (ein Takt ist alles, was ein _edge() oder 'event beinhaltet).

Sorry Leute aber ich komm absolut nicht weiter mit dem Zähler. Ich hab 
ja meinen clock mit 50Mhz laufen und soll nun einen neuen clock 
erstellen, nachdem meine Zustände pro Sekunde fortlaufen sollen. Ich 
check einfach nicht wie ich den Zähler einbinden muss. Muss ich einen 
extra process dafür schreiben, der parallel läuft ? Oder wird der zähler 
sequentiell ausgeführt, nachdem ein Zustand gesetzt wurde... kann es 
doch ja eigentlich nicht, weil der Zustand sich nach dem neuen clock 
richten muss ?!

Thomas K. schrieb:
> Sorry Leute aber ich komm absolut nicht weiter mit dem Zähler. Ich
> hab
> ja meinen clock mit 50Mhz laufen und soll nun einen neuen clock
> erstellen, nachdem meine Zustände pro Sekunde fortlaufen sollen. Ich
> check einfach nicht wie ich den Zähler einbinden muss. Muss ich einen
> extra process dafür schreiben, der parallel läuft ? Oder wird der zähler
> sequentiell ausgeführt, nachdem ein Zustand gesetzt wurde... kann es
> doch ja eigentlich nicht, weil der Zustand sich nach dem neuen clock
> richten muss ?!

Dein Zähler soll dir ja erstmal einen runtergeteilten Takt geben. Wie 
die beiden anderen schon geschrieben haben, reagierst du immer auf den 
Systemtakt. Egal was kommt. Ist dein Zähler abgelaufen, setzt du ein 
Flag, dass er abgelaufen ist. Auf ein Systemtaktereignis und dieses 
'Enable' hin kann deine Statemachine ihren Zustand wechseln.

Fang doch mal an, dir einen Prozess zu schreiben, wo du einen Zähler 
inkrementierst. Synthetisiere und simuliere das mal und guck auch mal, 
was für Logikelemente verwendet werden.

Hey Lothar. Leider habe ich noch nichts brauchbares hinbekommen. Lese 
zur Zeit die Lektüre und versuche eure Anregungen umzusetzen und 
vorallem auch zu verstehen. Vorallem will ich das mit den Zähler 
verstehen wie das im FPGA umgesetzt wird. Dein Link mit der blinkenden 
Led ist echt gut. Ich wusste z.B. nicht das alles was mit Zeiten zutun 
hat, mit Zählern realisiert werden kann. Beim Mikrocontroller hatte ich 
einfach ein Delay und schwups wars erledigt. Danke für die hilfreichen 
Tipps ! Super Forum =)

Halli Hallo.

Ich habe mal wieder ein kleine Frage und diesmal zu meinem Code. Ich 
hatte das eigentlich schon soweit fast fertig, aber musste noch einige 
Änderungen vornehmen, weil ich nicht einen eigenständigen Prozess für 
den clock geschrieben habe, sondern nach jeder Zustandsberechnung mein 
delay eingebaut hatte. Wie schon erwähnt würde ich wissen was bei mir 
nun noch falsch ist. Mir ist noch nicht ganz klar ob die beiden Prozesse 
parallel zueinander ablaufen, oder ob zuerst der Prozess für den clk 
sequentiell abläuft und dann erst die Folgezustandsberechnung 
sequentiell abläuft. Und was gehört dann alles in die Sensitivitätsliste 
für den Prozess der Folgezustandsberechnung?

Mfg

W.A.

guck dir doch mal das hier an und versuch dir danach eine Digitale 
Schaltung zu zeichnen, die dein Problem löst:
https://www.fbi.h-da.de/fileadmin/personal/e.komar/public_html/DGT-Skript-Teil2.PDF

Moin Moin.

Ich schon wieder.

Also, ich habe nun das Programm soweit fertig und laut meinem Prof. ist 
es soweit korrekt. Mir fehlt zur Zeit der Richtungsumkehr wenn mein 
Taster gedrückt wird. Meinen Code habe ich angehängt, habe jedoch nicht 
den kompletten Code angefügt, sondern einiges gelöscht, da ich sonst ja 
eine Lösung sozusagen veröffentliche. Meine Frage wäre demnach also wie 
ich das mit den Taster realisieren kann. Ich habe ja meine 8 Zustände an 
sich mit dem Zustand INIT, der dafür gedacht ist, dass alle Ausgänge 
zunächst auf 0 gesetzt werden und anschließend der Folgezustand 
ermittelt wird... Das läuft auch alles.. Nun habe ich mir gedacht, dass 
ich mir 8 weitere Zustände erschaffe, die einfach rückwärts laufen... 
also statt RGB dann RBG verlaufen... Ich hatte zuvor in meinem Prozess 
für die Zustandsaktualisierung geschrieben, dass auch abgefragt wird ob 
der Taster 0 oder 1 ist... und dann soll er halt bei einer '1' in den 
Zustand INIT1 springen und bei '0' in den Zustand INIT...Ist der Ansatz 
überhaupt richtig den ich habe, oder hat jemand einen Tipp wie ich es 
leicht realisieren kann?

Vielen Dank

W.A.

@ Lothar.

In deinem Beispiel arbeitest du doch mit einem Reset, der beim betätigen 
in den ersten Zustand wieder gelangt. Ich weiß nicht was ich damit 
anfangen soll. Gehe ich nach deinem Schema, so komme ich immer wieder zu 
dem Problem, dass ich immer wieder nur in die eine Richtung gehen kann. 
Sprich wenn der Taster nicht gedrückt ist, passiert nicht... halte ich 
es aber gedrückt, so gehts in die andere Richtung, solange die Taste 
gedrückt wird.

Hallo..

Ich bin echt am verzweifeln mit diesen Taster. Hab nun erstmal probiert 
ob ich beim drücken oder nicht drücken in die verschiedenen 
anfangszustände springen kann.. Das klappt. Der code sieht so aus.

process (clk,button) begin
 if clk = '1' and clk'event then

if button = '1' then
ZUSTAND <= ZINIT1;

else
ZUSTAND <=ZINIT;

end if;
end if;
end process;

Das Ding ist nun. Ich kriege es nicht hin den Folgezustand zu ermitteln 
wenn die Taste gedrückt oder nicht gedrückt ist. Kann ich das noch in 
dem Prozess irgendwie realisieren?

Ne, es läuft wenn dann nur in eine Richtung. Das mit der anderen 
Funktioniert noch nicht. Weshalb ist es wichtig, dass der Taster 
synchron ist?

Hmmm...

process(clk)
begin
if clk = '1' and clk'event then
    if (delay<=1500000) then
      delay<=delay+1;
    else
      delay <= 0;
      SystemTakt <= not SystemTakt;

      key <= button; << Taktsynchron?
      end if;
      end if;
end process;

Mal ne Frage.Ich habe ja hier mein Prozess und erzeuge ein weiteren Takt 
der langsamer ist.. Mein button ist mein externes Eingangssignal. Ist es 
nun synchron zum Takt und kann abgefragt werden?..das ist mir noch nicht 
ganz klar wie ich das machen soll mit der synchro. Hab die ganze Nacht 
dran gesessen und es kam nichts sinnvolles raus :/ Den obigen Link habe 
ich mir natürlich durchgeguckt. Ich denke mein Problem ist einfach nur 
das ich nicht den richtigen Weg finde um zwischen den Anfangszuständen 
zu springen und anschließend daraus die Folgezustände ermitteln kann..