Hallo zusammen Ich habe mir den Bresenham-Algorithmus mit 32-bit Integerwerten in der Sprache C codiert. Ist es nun möglich, mit den einfachen Mitteln, die einem Hobby-Programmierer bzw. Elektroniker zur Verfügung stehenden einem FPGA diesen Algorithmus beizubringen. Das Ganze sollte in etwa so funktionieren: Ein Mikrocontroller teilt dem FPGA über eine schnittstelle (z.B. SPI) die Start- und End Koordinaten mit. Mit jedem Takt, den der Mikrocontroller erzeugt, werden an den Ausgängen die Richtungswerte für den nächsten Schritt ausgegeben. Geht das und falls ja, mit welchen Software-Tools würdet Ihr hier bitte arbeiten? Kann man so einen FPGA auch in C programmiern? Beste Grüsse und vielen Dank Geri
wenn das FPGA einen Prozessor nachbildet, geht das schon. Das FPGA selbst wird aber in einer Hardware-Beschreibungssprache programmiert, VHDL oder Verilog
Hallo Christoph Vielen Dank für Deine rasche Rückmeldung und die Infos. Ich habe mir gedacht, weil der Bresenham-Algorithmus lediglich aus Additionen/Subtraktionen und Grösser-Kleiner-Abfragen besteht, müsste es irgendie doch einfach möglich sein...:) Wenn ich es richtig verstanden habe, dann ist VHDL ja wie eine Hochsprache, in der man Variablen definieren kann und die oben beschriebenen Operationen codieren kann. Ist das aber auch mit Hobby-Mitteln möglich oder muss man zuerst ein paar K hinlegen, damit man was vernünftiges machen kann:)? Wenn ich auch richtig verstanden habe, dann ist VHDL an Pascal angelehnt und es gibt die Möglichkeit von Abragen, Datentypen wie interger und Real. Beste Grüsse Geri
>Ist das aber auch mit Hobby-Mitteln möglich Die Software kostet nix. Ausser Du benutzt Riesen-FPGAs, die selber schon mehrere hundert Euro kosten. >Wenn ich auch richtig verstanden habe, dann ist VHDL an Pascal >angelehnt und es gibt die Möglichkeit von Abragen, Datentypen wie >interger und Real. Böse Falle. "VHDL programmieren" zu sagen ist eigentlich schon falsch. VHDL schaut auf den ersten Blick zwar aus wie eine gewöhnliche Programmiersprache, ist aber eine Beschreibungssprache. In VHDL beschreibt man Hardware per Text. So wie man mit einem Bauplan das Aussehen eines Hauses beschreibt. Ja, es gibt for-Schleifen, aber die sind eher eine Makroexpansion wie bei einem Assembler, um Dir Tipparbeit zu sparen. Du sollest wissen wie die digitale Hardware ausschaut, die Du in VHDL beschreibst, sonst wird das nix. Am besten mal einen Blick in ein Buch über Digitaltechnik und VHDL werfen.
Der Unterschied ist, dass Prozessoren alles nacheinander ausführen, während die Hardware im FPGA oder CPLD gleichzeitig voneinander unabhängige Aufgaben ausführt. Das Synchronisieren dieser gleichzeitigen Abläufe muß mit der Programmiersprache möglich sein, dazu gibts eine Timing-Analyse. Ein einziger zentraler Takt ist nicht immer vorhanden.
@XENU - Danke bzgl. der Info zur Software. Danke auch für die Richtigstellung bzgl. der Programmierung ..äh Hardwarebeschreibung. Wenn ich dich nun richtig verstehe, dann müsste ich nun, wenn ich den Bresenham-Algoritmus in Harware realisieren möchte, die digitale Logik davon kennen. Ich kann mir schon vorstellen, dass ich das hinbekomme, mir käme der Lösungsweg allerdings sehr kompiliziert vor. ..oder gibt es da vielleicht Bibliotheken, (Hardware-Beschreibungen), in denen Standard-Probleme wie das von mir erläuterte bereits beschrieben sind? @Christop: Das kann ich gut nachvollziehen und ich denke, die Möglichekeit der Modularisierung und parallelen Verarbeitung sind zwei wesentliche Stärken dieser Technologie. Aus Gründen der Geschwindigkeit möchte ich keinen Controller verwenden. Allmein hätte ich nur gedacht, der Algorithmus liesse sich einfach in VHDL umsetzen weil ich auch gelesen habe, dass FFT möglich sei. Vielleicht habe ich da auch voreilig etwas zu optimistisch gedacht. Freundliche Grüsse und nochmals vielen Dank für Eure Infos Geri
Moin... äh, kleines Missverständnis. Der Algorithmus ist durchaus in VHDL abzubilden. Nur musst du berücksichtigen, das du das Verhalten EINES Taktes beschreibst. Eine Schleife wird also komplett aufgelöst und in Logik dargestellt! Mit zwei geschachtelten FORs und drei Abbruchbedingungen, kein Ding für jeden noch so kleinen µC, kann man ganz fix mal die größten FPGAs in die Knie zwingen. Formulierst du das ganze so wie ein "normales" Program, versucht die Synthese Software das so im Chip zu verteilen das der ganze Ablaufin einem Takt erfolgt. Allerdings frage ich mich, was die Motivation ist? -- SJ
>Wenn ich dich nun richtig verstehe, dann müsste ich nun, wenn ich den >Bresenham-Algoritmus in Harware realisieren möchte, die digitale >Logik davon kennen. Nicht Gatter-für-Gatter, aber Ahnung von digitaler Logik wäre schon nötig. Was Flip-Flops, Latches und kombinatorische Logik sind, sollte man schon wissen. >Ich kann mir schon vorstellen, dass ich das hinbekomme, >mir käme der Lösungsweg allerdings sehr kompiliziert vor. Naja, sooo komplex ist nun auch wieder nicht. Wenn ich z.B. einen Zähler in VHDL schreibe, kann man das schon relativ einfach machen: if(rising_edge(clk) then count <= count + 1; end if; "count" ist hierbei ein Vektor aus mehreren Bits, z.B. 8 bei 'nem 8-Bit-Zähler. Das heisst, Du musst jetzt nicht die einzelnen Flip-Flops zusammenkleben (obwohl das in VHDL auch geht), der VHDL-Synthesizer macht das dann für Dich. Aber wer keine Ahnung von Digitaltechnik hat, der weiß halt erst gar nicht, daß ein Zähler aus Flip-Flops besteht, was ein Flip-Flop überhaupt ist und daß diese einen Takt brauchen, etc.
Hallo zusammen @Sven: Vielen Dank für Deine Infos. In meinem Fall müsste man keine Schleife implementieren weil der nächste Berechnungsschritt -also die Berechnung des nächsten Punktes - durch ein externes Taktsignal, welches von einem Mikrocontroller kommt getriggert wird. Die Aufgabe wäre demnach einen Algorithmus, wie im Anhang dargestellt wird zu implementieren (Die Startparameter habe ich weg gelassen, weil sie vom Mikrocontroller berechnet und die Parameter in den FPGA geschrieben würden). @XENU: Mit digitaler Logik bin ich vertraut. Man müsste mit dem FPGA aber 1.) z.B. über eine SPI-Schnittstelle die Startparameter an den FPGA senden können. 2.) wie man am Algorithmus sieht, etwa 10 32bit-Variablen und einige 8-bit Variablen definieren können 3.) den Algorithmus umsetzen können Wie Punkt 3 für mein konkretes Beispiel in etwa aussieht, habe ich aktuell noch nicht so vor meinen Augen. Beste Grüsse und nochmals vielen Dank für Eure Tipps!! Die FPGAs sind wirklich ein sehr spannedes Thema! Geri
Moin... Wenn das dein ganzer Alg. ist, kannst du den fast 1:1 in VHDL runtertippen. Die Synthese Software haut dir das Ding schon klein, ein Block geschafft. Viel spanender ist das Interface. In jedem Fall brauchst du Register, also entweder RAM oder FF um deine Parameter abzulegen. Nach draussen dann entweder parallel mit Daten/Adr und enable und die Register vollschreiben oder halt einen seriellen Port nachbauen, wieder zwei Funktionsblöcke. Zerlege das Problem einfach in mehrere Häppchen und implementiere sie nicht als einen Haufen. Wird nichts. -- SJ
Hallo Sven Vielen Dank für Deine Anregungen. Ich habe mir auch irgendwie gedacht, dass ich von Aussen ein spi Internface implementiere. Intern einige 32-bit Latches um die notwendigen Parameter zu speichen. Sobald einer der Funktionsblöcke des FPGAs initialisiert ist wird mit jedem Taktimpuls von Aussen her der nächste Punkt berechnet und ausgegeben. Deine Überlegung, ein Stück des internen Ram zu Verwenden finde ich aber fast noch besser. Wenn man nun die Komplexität des Algorithmus betrachtest, kann man da eigentlich ganz grob abschätzen mit welchen Taktfrequenzen ein Schritt in etwa ausführbar ist? Liegt es im KHz-Bereich im MHz-Bereich - nur ganz grob? Wenn ich diesen Algorithmus implementiere, wie viel der Ressourcen des gesamten FPGAs habe ich damit verbraucht. Ich gehe von einem Standard-FPGA z.B. von ALTERA aus, der für im Hobby-Bereich inkl. der Entwicklungssoftwar erschwinglich ist. Welche FPGAs verwendet ihr eigentlich für Eure Entwicklungen? Ich nehme an, es ist wie bei den Mikrocontroller. Da gibt es auch Standard-Typen die Hobby-freundlich (grosse Gemeinde, die sie verwendet, viele Beispiele verfügbar, breite Einsatzmöglichkeit, einfache Programmierung, leicht lötbar...) Beste Grüsse und nochmals vielen Dank Geri
Moin... "schätzen" kann nur die Synthese Software, als Mensch macht das kaum Sinn; der Überblick fehlt. Wenn du keine Pipeline akzeptieren kannst müssen alle Aktionen in einen Takt passen, also pro Addition einige 10ns. Optimiert man auf Geschwindigkeit werden alle Alternativen (if..) parallel berechnet und "am Ende" der richtige Wert ausgewählt. Soviel zum Thema Platzbedarf. Irgendwann kommen dann die Laufzeiten zu tragen undundund... Standard Typen gibts wohl kaum, ich wage aber zu behaupten das Verfügbarkeit und Gehäuse DIE Argumente sind. Also TQFP liegt im Hobbybereich sicherlich weit vorne. S3 gibts schwer in Kleinmenge, S2 schon eher. Im Vergleich zu den µC Gemeinden aber eher kleine Besetzung. Bei Altera kenne ich mich nicht so aus, aber da gibts auch was. SW ist bei beiden frei für privat. Atmel und Lattice gibts noch, aber die kommen zusammen auf keine 10% Marktanteil. Zum "basteln" privat habe ich S3 liegen, mein letztes Projekt war Portierung von mächtig-alt auf V2p/V4; also im Endeffekt wegschmeissen und neu. Momentan bin ich beruflich ab von der Materie. -- SJ
Hallo Sven Vielen Dank für Deine ausführliche Nachricht. Mit Ausgabegeschwindigkeiten von 100KHz bin ich im jedenfalls im "grünen" Bereich. Da komme ich hin. Bzgl. Standard-FPGA habe ich einfach gemeint, dass es unter den hier Forum-Anwesenden Favoriten gibt, weil sie genau die von mir beschriebenen Kriterien erfüllen. Die Verfügbarkeit - wie du schreibst - gehört hier jedenfalls auch dazu. Für mich stellt zudem auch die Frage wie viel Ressourcen ich für die Implementation von so einem Algorithmus benötige. Mich interessiert es nur deshalb weil ich gerne wissen möchte wie leistungsfähig diese Bauelemente sind. Beste Grüsse und nochmals vielen Dank Geri
Hi Geri, wenn ich Dich richtig verstehe willst du wissen welchen FPGA du verwenden sollst. Mein Tipp: Hol dir z.B. die (kostenlose) Entwicklungssoftware von ALTERA (MAX+ oder Nachfolger) und schreib dein Programm. Dannach kannst Du verschiedene FPGA-Typen (mit MAX+ glaub ich nur ALTERA) auswählen und simulieren, um zu sehen, wie "schnell" sie sind und in wie weit das Bauteil mit dem Programm ausgelastet wäre. Die Infos zur Auslastung, die dir das Programm liefert, glaub ich, stimmen recht gut. Das mit der Geschwindigkeit ist nicht so wahnsinnig genau, da die Bearbeitungszeit auch von Versorgungsspannung, Qualität des jeweiligen Bauteils, etc. abhängt. Wenn du´s dann ganz genau wissen willst, wirst nachmessen müssen. gruss
Hallo Markus Vielen Dank für Deine Info. Ich denke, du hast recht, eine sehr gute Idee. Liege ich da richtig: Meinst du die Software Quartus II? Beste Grüsse Geri
Hi, ja, soweit ich weiss heißt die neue Enwicklungsumgebung von ALTERA jetz QuartusII. Ich hab nur Erfahrung mit MAX+, weil wir das im Studium verwenden, aber ich denk das Quartus wird ähnlich aufgebaut sein. Für MAX+ hätt ich noch eine 20-Seitige Einführung, die is recht gut, in wieweit die dann auch für Quartus geeignet ist, wieß ich ned. gruss
Hallo Markus Vielen Dank für Deine Infos zur Entwicklungsumgebung. Es wäre nett von Dir, wenn du mir die Einführung bitte schicken würdest. Bestimmt sind darin einige interessante Informationen für den Startup. Freundliche Grüsse und nochmals vielen Dank Geri
"Die Infos zur Auslastung, die dir das Programm liefert, glaub ich, stimmen recht gut. Das mit der Geschwindigkeit ist nicht so wahnsinnig genau, da die Bearbeitungszeit auch von Versorgungsspannung, Qualität des jeweiligen Bauteils, etc. abhängt. Wenn du´s dann ganz genau wissen willst, wirst nachmessen müssen. " Quartus generiert nach der Synthese ein output file, welches das Timing der real erzeugten Strukturen beschreibt. Damit kann man dann nachsimulieren. Allerdings weiss ich nicht, ob das in der kostenlosen Version auch geht.
Hallo Jürgen Vielen Dank für Deine Info. Euren Meldungen nach zu urteilen, komme ich zum Einstieg alleine mit der Software aus. Das finde ich toll. Momentan lese mich nun zum Thema ein. So wie es auch aussieht, ist VHDL recht übersichtlich und leistungsfähig. Eine neue Frage bzgl. Implementierung hat sich bei mir aber inzwischen wieder ergeben. Nehmen wir an auf dem FPGA läuft ein Algorithmus in einer Schleife. Die Geschwindigkeit wird durch einen internen Takt vorgegeben, dessen Frequenz in einer Variable (Timer-Reload) gespeichert ist. Die Timer-Reload-Variable ist eine Funktion der Zeit (z.B. 1.) beschleuningen 2.) konstanter Takt/Geschwindigkeit 3. verzögern). Habt ihr schon einmal so etwas ähnliches implementiert? Wie würdet ihr dieses Problem lösen. Würdet ihr das Geschwindigkeitesprofil (z.B. Spline als Algorithmus implementieren) oder Reloadwerte in eim RAM speichern? Übersteigt die Komplexität wahrscheinlich die Fähigkeiten von FPGAs? Beste Grüsse Geri
Moin... ich verstehe jetzt nicht ganz was du da machen möchtest. Wenn es um einen Takt geht, der abhängig von einer weiteren Variable geteilt wird, ist das mit Sicherheit nicht zu komplex für FPGAs. Die "Schleife" verstehe ich jetzt nicht. So ein logisches Konstrukt wird in der Synthese eingeebnet und in einem Takt abgearbeitet. Diese Takt wird dann evtl. länger, aber das ergit sich dann in der Timinganalyse. -- SJ
Hallo Sven Ich möchte foldendes machen: Auf dem FPGA läuft ein Algorithmus in einer For-Schleife. In jedem Schleifenzyklus werden drei Koordinaten berechnet und entsprechend digitale Ausgänge gesetzt. Dann wird eine Zeit lang - sagen wir DeltaT - gewartet. DeltaT ist eine Funktion der Zeit und ist eine zusammengesetzte Funktion oder ein Spline. In Pseudocode könnte es etwa folgendermassen aussehen void Process(void) { unsigned Long CurrentTime = 0; for i=0 to 5000 { Berechene Werte setze digitale Ausgäne entsprechend der berechneten Werte DeltaT = BerechneDeltaT(CurrentTime) warte DeltaT } } // einfache Beispielfunktion Rampe auf - Kontstante - Rampe ab // könnte aber auch ein Spline sein unsigned int BerechneDeltaT(unsigned long CurrentTime) { static unsigned int DelayValue = 0; if CurrentTime <= 500 DelayValue = CurrentTime + 25; else if CurrentTime > 500 DelayValue = 500; else DelayValue = DelayValue - 20; return DelayValue } so sollte es in etwa aussehen..:) Beste Grüsse Geri
ach ja, das habe ich noch vergessen: CurrentTime läuft auf einem 32-bit-Zähler und wird jede uS erhöht. Beste Grüsse Geri
Moin... naja, genaus DAS kann ein FPGA nicht. Die Synthese macht daraus EINEN Takt. Warten geht übrigens garnicht. Was soll nebenbei void? Prozesse müssen von irgedetwas angestossen werden und haben sowieso keinen Rückgabewert. Lass die Schleife weg, und füge einen Takt als Trigger ein. Der Wert zum warten sind dann Takte zwischen der Ausgabe neuer Werte. Mach dich doch ersteinmal darüber schlau, wie ein FPGA funktioniert; es ist ebend keine CPU mit einem zeitlich sequentiellen Verhalten. -- SJ
Hallo Sven Vielen Dank für Deine Rückmeldung. Mir ist schon klar, dass der FPGA nicht warten kann. Ich wollte mit dem Pseudocode auch nur die Problematik aufzeichnen. Die Realisierung der Wartzeit wäre ja ganz einfach zu lösen indem man einen Timer initialisiert und der Überlauf die Weiterschaltbedinung ergibt. void soll im dargestellten Falls signalisieren, dass die Routine keinen Rückabewert hat.. wie gesagt, Pseudocode nicht ganz genau nach Spezifikation von Jackson. Die Frage stellt sich für micht vielmehr wie ihr die Funktion zur Berechnung des Reload-Wertes berechnen würde wenn die Funktion z.B. ein Spline wäre. Beste Grüsse Geri
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.