ich studiere Wi-Ing Richtung E-Technik und hatte daher ein Einführungskurs in Java. Nun steht meine Bachelorarbeit bevor und ich soll eine LED-Beleuchtungssteuerung in VHDL implementieren. Soweit so gut. Nun ist jedoch noch ein Teil der Arbeit, dass ich eine prototypische Realisierung einer Software zur Bedienung der Dimmereinheit schreibe. Das soll mit Java gemacht werden. Mein Problem:
Ich habe keine Vorstellung wie ich das anstelle. Das FPGA mit VHDL zu programmieren bekomme ich hin, aber wie ich dann mit Hilfe von Java eine Software programmieren kann, bei der ich dann z.B. die Helligkeit von LED 1 ansteuere, ist mir schleierhaft. Ich will ja die Regelung der Helligkeit usw mit VHDL machen. Wie kann man das verbinden? Kann ich irgendwie mit Java den VHDL-Code beeinflussen? Wie gesagt ich habe noch nicht einmal eine Vorstellung wie ich hier vorgehen kann/soll. Wäre nett wenn einer eine Idee dazu hat, bzw weiß wie man soetwas lösen kann.
Naja, du müsstest halt zwischen dem Gerät, auf dem das Javaprogramm läuft, und deinem FPGA-Board irgendeine Verbindung herstellen. RS232, USB, Bluetooth, IRDA, eigenes serielles Protokoll - wie auch immer. Von Java aus könnte man das dann z.B. mit der Java Communication Api (aka javax.comm) ansteuern. Hat das FPGA-Board zufällig irgendwelche fertigen Anschlüsse die man nutzen könnte? Oder sollst du das Board auch selbst entwickeln? Oder sollst du eine JVM in VHDL schreiben, auf der das Steuerprogramm dann läuft? :o)
Ich würde da erstmal beim Prof. nachfragen was der sich vorstellt. Sonst macht man sich nachher viel Arbeit, arbeitet aber am Thema vorbei.
Also ja es gibt einige fertige Anschlüsse, die man benutzen kann. Das Gerät auf dem das Programm läuft soll einfach mein PC sein. Okay, mit der der Java Com. Api könnte ich dann über den Anschluss auf das FPGA zugreifen. Aber die Steuerung der LEDs schreibe ich ja mit VHDL. Dann müsst ich das ganze ja nochmal mit Java machen, das ist so nicht gedacht denke ich.
„Oder sollst du eine JVM in VHDL schreiben, auf der das Steuerprogramm dann läuft?“
Wenn ich den Satz richtig verstehe, ist die Antwort nein. Ich habe zu dem Board, auf dem mein FPGA ist, eine Software, mit der ich auf das FPGA zugreifen kann. Also ich kann meinen VHDL-Code in die Software schreiben und die überträgt das dann auf das FPGA.
Man könnte theoretisch die ganze Steuerung auch mit Java schreiben und dann würde man das ja auch mit ner GUI schön darstellen können, aber ich soll die Steuerung halt mit VHDL machen und scheinbar nur die Software zur Dimmereinheit mit Java.
Hm, auf dem Board ist noch ein Drehschalter, der für die Dimmung verantwortlich ist. Da kann ich mir aber nur vorstellen die Funktionsweise mit VHDL zu implementieren.
Kann man irgendwie mit Java eine Oberfläche programmieren und dann klickt man dort z.B. auf „heller“ (ja das geht mit ner GUI) und das hätte dann den selben Effekt als wenn ich diesen Drehschalter eins nach rechts verschieben? Also dann müsste ich die beiden Sprachen so verzweigen, dass ich bei einem Klick in der Java-Oberfläche einen veränderten Input für meinen VHDL-Code habe. Als Aktion auf das Klicken müsste ich also in den VHDL-Code gelangen, bzw der VHDL-Code muss das als Input erkennen können.
Vielleicht sollte ich dann eher in einem VHDL-Forum nachfragen Aber ob die ganze Sache wirklich so gemeint ist habe ich mir jetzt nur so gedacht. Kann sich jemand vorstellen, dass sowas geht?
Der Anwender kann bei dem Javaprogramm eingeben was mit den LEDs geschehen soll (z.B. „LED 1 soll um 50% heller werden“). Mit dieser Befehlseingabe hat der FPGA nichts zu tun.
Das Javaprogramm formuliert daraus einen entsprechenden Befehl für den FPGA. Einen solchen Befehl könnte man z.B. in drei Bytes codieren: [Aktion] [LED-Nummber] [Parameter].
Diese drei Bytes bzw. 24 Bits müsste man dann zum FPGA übertragen. Auf welche Weise das geschehen soll ist gerade die Frage. Falls das FPGA-Board ein paar freie IO-Pins hat dann kann man die nutzen um die Bits einzeln mit Handshake zu übertragen, das reicht bei einer zeitunkritischen unidirektionalen Übertragung ja völlig aus. Alternativ müsste man sich halt damit auseinandersetzen wie man auf dem Board vorhandene Anschlüsse mit VHDL ansteuert.
Der FPGA interpretiert die empfangenen Befehle und setzt sie um. Wie diese Umsetzung geschieht, damit hat die Java-Software wiederum nichts mehr zu tun. Der FPGA könnte die LEDs bspw. per PWM ansteuern.
Auf diese Weise hätten das Javaprogramm und der VHDL-Code getrennte Aufgabenbereiche. Wenn dir der VHDL-Teil zu simpel erscheint kannst du ja beliebig komplizierte Befehle vorsehen, z.B. um ein Lauflicht zu starten oder die LEDs Muster darstellen zu lassen.
Aber das ist halt alles nur Spekulation von mir. Letztendlich wird dir nur dein Auftraggeber sagen können was er genau sehen will.
[QUOTE=Unregistriert]„Oder sollst du eine JVM in VHDL schreiben, auf der das Steuerprogramm dann läuft?“
Wenn ich den Satz richtig verstehe, ist die Antwort nein.[/Quote]
Das war auch nur als Witz gemeint.
Gleichwohl gibt’s sowas aber offenbar schon: JOP
Jo, so würde ich das auch sagen.
PS @MZ80A : Wobei bei der Synthese kein „Maschinencode“ erzeugt wird (es gibt ja keine CPU auf der dieser Code laufen könnte) sondern eher eine Netzliste.
[QUOTE=MZ80A]Nach kurzem Lesen(ich kannte VHDL nicht):
Das ist doch „nur“ eine Beschreibungssprache, aus der Maschinencode erzeugt wird?
[/QUOTE]
Genau
Joa, aber was hilft das, bzw was meinst du? Sowas wird doch meistens/immer mit Ports gemacht?
[QUOTE=Dow_Jones;28894]Ich stelle mir das gerade so vor:
Der Anwender kann bei dem Javaprogramm eingeben was mit den LEDs geschehen soll (z.B. „LED 1 soll um 50% heller werden“). Mit dieser Befehlseingabe hat der FPGA nichts zu tun.
Das Javaprogramm formuliert daraus einen entsprechenden Befehl für den FPGA. Einen solchen Befehl könnte man z.B. in drei Bytes codieren: [Aktion] [LED-Nummber] [Parameter].
Diese drei Bytes bzw. 24 Bits müsste man dann zum FPGA übertragen. Auf welche Weise das geschehen soll ist gerade die Frage. Falls das FPGA-Board ein paar freie IO-Pins hat dann kann man die nutzen um die Bits einzeln mit Handshake zu übertragen, das reicht bei einer zeitunkritischen unidirektionalen Übertragung ja völlig aus. Alternativ müsste man sich halt damit auseinandersetzen wie man auf dem Board vorhandene Anschlüsse mit VHDL ansteuert.
[/QUOTE]
Das klingt gut!
Also der User klickt z.B. auf den Button „LED 1“, dann auf „heller“ und auf „50%“. Das wird dann zusammengesetzt zu einem 24Bit Wort (also als Aktion speichere ich die Werte der gewählten Alternative in einer Variablen und füge dann die 3 Variablen zusammen). Wie kann ich jetzt diese Bits auf das FPGA bringen? Also du hast ja das Java Com. Api angesprochen, damit? Was meinst du mit einzeln übertragen?
Das war der Plan
Du kannst Gedanken lesen, so habe ich mir das auch gedacht.
[QUOTE=Unregistriert]Das klingt gut!
Also der User klickt z.B. auf den Button „LED 1“, dann auf „heller“ und auf „50%“. Das wird dann zusammengesetzt zu einem 24Bit Wort (also als Aktion speichere ich die Werte der gewählten Alternative in einer Variablen und füge dann die 3 Variablen zusammen). Wie kann ich jetzt diese Bits auf das FPGA bringen? Also du hast ja das Java Com. Api angesprochen, damit? Was meinst du mit einzeln übertragen?
[/quote]
Ich habe mir javax.comm jetzt nicht genau angesehen, aber zumindest gibt’s da ja eine Klasse um den Parallelport anzusprechen. Von dem kann man sich prinzipiell ein paar Leitungen abzwacken um sie mit dem FPGA-Board zu verbinden. Drei Leitungen (Data, Valid, Ready) reichen ja locker für eine simple serielle Übertragung. Schöner wäre es natürlich eine standarisierte Schnittstelle wie RS232 zu verwenden (gibt’s sicher schon fertig in VHDL; ob du anderer Leute Code nutzen darfst musst du freilich mit dem Dozenten klären), aber RS232 arbeitet mit 12 Volt - was für das Board problematisch werden könnte. Andere Schnittstellen wie USB sind ungleich komplexer. Da macht eine selbstgebastelte Schnittstelle schon Sinn…
By the way - welche Anschlüsse hat dein Board eigentlich?
Das nicht, aber ich weiss wie schön man mit LEDs herumspielen kann.
PS: Frag auch mal die Jungs und Mädels bei microcontroller.net, die können dir in Sachen FPGA und Übertragungsprotokollen noch eher weiterhelfen als wir. (aber falls du dorthin abwanderst vergiss bitte nicht hier ab und an mal einen Zwischenstand deiner Arbeit zu posten! Interessiert mich schon. )
Also es gibt 2 RS 232 9-Pin Anschlüsse, dann noch „Ethernet 10/100 Phy“, JTAG - USB und noch ein Anschluss, der aussieht wie das Gegenstück vom RS 232, weiß aber nicht wie der heißt.
„zumindest gibt’s da ja eine Klasse um den Parallelport anzusprechen“
Mit Parallelport meinst du den Port am FPGA? Also gibt es eine Klasse, die die Übertragung managed?
Das mit dem Code von anderen Leuten verwenden werde ich mal nachfragen und über die microcontroller-Seite bin ich auch schon gestolpert, die ist echt gut. Werde euch auf jeden Fall auf dem Laufenden halten, da ich sicherlich noch einige Probleme haben werde, bei denen ihr mir vielleicht helfen könnt
Danke bis hierhin, bin ab morgen erstmal für eine Woche im Urlaub und werde danach dann richtig loslegen.
Also ich bin jetzt schon ein ganzes Stück weiter vom Verständnis her und der VHDL-FPGA Teil ist relativ klar. Ich habe aber noch ein Problem mit der JAVA communication API. Habe mir schon ein wenig was dazu durchgelesen…
Es gibt also das Package javax.comm, welches Klassen zur Verfügung stellt, die ich benutzen kann. Hier kann man zB mit der Methode getPortIdentifiers() Ports finden. Heißt das, es werden alle Ports angezeigt, die der PC besitzt?
Um jetzt die Kommunikation durchzuführen soll man zuerst den Port öffnen, wenn der Port verfügbar ist, wird wird ein CommPort Objekt zurückgegeben.
Heißt, wenn ich ein USB-RS232 Adapter benutzen will (mein PC hat keinen RS232 Anschluss) muss ich den USB Port öffnen. Woher weiß ich wie dieser Port heißt?
Um den Eingabestrom zu bestimmen kann man scheinbar die Methode getInputStream() benutzen. Wie die Funktioniert habe ich noch nicht begriffen. Wie kann ich hier festlegen, dass zb eine 101011100 auf meinem FPGA ankommt?
Am Ende noch den Port close() en und man ist fertig.
Wo schreibe ich all das überhaupt rein? Ich programmiere meine GUI, die mir Binärwerte erstellen soll, also habe ich meine Klasse “Software-LED” z.B. Jetzt habe ich eine andere Klasse, die das mit den Ports regelt. Muss ich einfach beide Klassen public machen, ins selbe Package stecken und dann kann ich bei getInputStream() sowas wie Software-LED.getBinaerwert() hinschreiben?
mein letzter Absatz war murks, man wird wohl einfach in die Klasse, in der ich das mit den Ports regele ein Objekt der Klasse „LED-Software“ erzeugen und dann die Methode „getBinaerwert()“ aufrufen oder?
Die ist doch ziemlich eindeutig. Es kommt ja darauf an, welche Ports das System zur Verfügung stellt, bzw. auf welche zugegriffen werden können.
Mit der Enumeration die du zurückbekommst, solltest du zumindest alle Ports anzeigen können. Wenn du mehrere Gleiche Ports am Rechner hast, dann muß ja auch entschieden werden an welchem dein Gerät hängt.
Hardware ist jetzt nicht mein metier, aber ein usb2serial Adapter sollte doch zumindest einen virtuellen Port zur Verfügung stellen.
Einfacher ist es wohl, wenn du rxtx nimmst. Statt im package javax.comm, sind die Implementierungen unter gnu.io zu finden. Der Rest sollte sehr ähnlich, bzw. gleich sein. Rxtx bietet auch noch zusätzliches was in javacomm nicht dabei ist.
Mal zum Verständnis, wenn ich jetzt in einer Klasse "import gnu.io.* " kann ich in dieser Klasse auf alle Methoden zugreifen, die in gnu.io implementiert sind oder?
“Access restriction: The type CommPortIdentifier is not accessible due to restriction on required library C:\Program Files\Java\jre7\lib\ext\RXTXcomm.jar”
Aber ob die ganze Sache wirklich so gemeint ist habe ich mir jetzt nur so gedacht. Kann sich jemand vorstellen, dass sowas geht?
