Was ist die Arduinospielwiese?


Was brauchst Du?


Experimente &
Projekte


Downloads &
Links


häufige Fragen

Impressum

Wie geht serielle Datenübertragung mit Java? (alte Version)


Ziel:   Java-Programme, sog. "Frontends", senden und empfangen Informationen über USB zu/von Arduino.


Java-Program?

Es ist eine gute Idee, Java zu verwenden.

  • Einerseits läuft Java auf allen möglichen Betriebssystemen.

  • Andererseits liefern viele Java-Entwickler Programmbausteine, die wir für unsere Projekte nutzen können.
    Wir werden gleich so ein Programmpaket benutzen.

  • Ein Lernziel dabei ist es auch, dass Du mit Java Kontakt aufnimmst.
    Demnächst     gibt es auf der Arduinospielwiese vielleicht auch einen Java-Einführungskurs. 

Arduino → Computer:

Die Programme können dazu dienen, Informationen oder Daten auf dem Computer als Zahlen, Zeigermessgeräte, Diagramme oder Kennlinien auszugeben. Eine weitere Anwendung kann darin bestehen, vom Arduino kommende große Datenmengen auf dem Computer auf Festplatte oder in Datenbanken zu speichern.


Computer → Arduino:

Die Programme können dazu dienen, mittels auf ihnen befindlichen Tasten, Checkboxes oder Sliders Zustände und Vorgänge im Arduino zu beeinflussen, um so z. B. Leuchtdioden oder Motoren zu steuern.



    Hier einige Beispiele:

Ardunino sendet periodisch einen Zahlenwert an den Computer.
Dort wir dieser in einer Konsole ausgegeben.

Dies ist das Einstiegsexperiment.
Du findest es am Ende dieser Seite.




Ardunino sendet periodisch seine 6 Analogwerte an den Computer.
Dort werden sie in einer Konsole ausgegeben:




Ardunino sendet periodisch seine 6 Analogwerte an den Computer.
Dort werden sie in einem Fenster als Zahlen ausgegeben:




Ardunino sendet periodisch seine 6 Analogwerte an den Computer.
Dort werden sie in einem Fenster als Balken ausgegeben:




Ardunino sendet periodisch seine 6 Analogwerte an den Computer.
Dort werden sie in einem Fenster mittels Zeigerinstrumenten ausgegeben:




Ardunino sendet periodisch seine 6 Analogwerte an den Computer.
Dort werden sie in einem Fenster als Kennlinien ausgegeben:




Ein Fenster mit einem Slider liefert einen Wert, der seriell zum Arduino übertragen und im LCD ausgegeben wird:

    




Ein Fenster mit sechs Sliders liefert sechs Werte, die LCD ausgegeben werden:

     




Ein Fenster ermöglicht die Eingabe von Text, der im LCD des Arduino ausgegeben wird:

     


  

Das Einstiegsexperiment: eine Java-Programm, das mittels jssc mit Arduino kommuniziert:

Was nun folgt, soll keineswegs ein Java-Grundkurs sein - den gibt es vielleicht später mal auf der Arduinospielwiese.
Ich will hier nur kurz die Vorgehensweise darlegen, wie man den unten zu findenden, fertigen Java-Programmcode für das Frontend zum Laufen bekommt.

Ich benutze zur Java-Programmierung gern Eclipse.
Unter anderem, weil es unter Windows, Linux und Mac OS X läuft.
Für andere Java-Programmierfreunde ist Netbeans die erste Wahl.

Ich zeige Dir hier, wie man in Eclipse vorgeht.


Wenn Du noch nicht weißt, was ein Analogwert ist, dann lies erst hier!
Es gibt auch hier ein einfacheres Experiment, bei dem ein Analogwert zum Computer gesendet wird.



Schaltung:


       



Arduino-Programm:

Arduino holt sich von seinem Analogeingang A0 einen Wert zwischen 0 und 1023 und sendet ihn seriell zum Computer.
Der Wert wird zum String umgewandelt und zwischen zwei Zeichen eingeklemmt: vorn ein @ und hinten ein #.
Dies habe ich getan, weil mir das die Möglichkeit gibt, festzustellen, ob ein vollständiger Zahlenwert (und später auch mehrere Werte) seriell angekommen sind.

void setup() {
  Serial.begin(9600);
}

void loop() {
  int wert = analogRead(A0);
  String myString = "@" + String(wert) + "#";
  Serial.println(myString);
  Serial.flush();
  delay(1000);
}



Java-Programm:

Ist Eclipse installiert und gestartet, legst Du ein neues Java-Projekt (z. B. "Arduino") an - der Name des Projektes ist egal.

Aber die folgenden Namen solltest Du wie gefordert vergeben, damit Du später den untenstehenden Java-Programmcode exakt so bei Dir einfügen kannst.

In diesem neuen Java-Projekt legst Du ein neues Package namens: "arduinosendet" an.
In diesem Package legst Du eine neue Klasse namens "EinenAnalogWertInConsoleAusgeben" an.

Ist die geforderte Klasse bei Dir angelegt, steht schon einwenig Code darin.
Den kannst Du komplett löschen und statt dessen dort den folgenden Programmcode hineinkopieren:


package arduinosendet;

import javax.swing.JFrame;

import jssc.SerialPort;
import jssc.SerialPortEvent;
import jssc.SerialPortEventListener;
import jssc.SerialPortException;

@SuppressWarnings("serial")
public class EinenAnalogWertInConsoleAusgeben extends JFrame implements SerialPortEventListener {

    // hier musst Du Deinen seriellen Port eintragen
    private SerialPort sp = new SerialPort("/dev/tty.usbmodem24131");
   
    // darin wird das seriell Ankommende gesammelt
    private String sammler = "";

    public EinenAnalogWertInConsoleAusgeben() {
        try {
            sp.openPort();
            sp.setParams(9600, 8, 1, 0);
            sp.addEventListener(this);
        } catch (SerialPortException ex) {
            System.out.println(ex);
        }
    }

  

    @Override
    public void serialEvent(SerialPortEvent e) {
        try {
            sammler += sp.readString();
           
            // Muell herausfiltern
            sammler = sammler.replaceAll("null", "");
            sammler = sammler.replaceAll("\n", "");
            sammler = sammler.replaceAll("\r", "");

            // Test auf Vorhandensein von "@" und dahinter "#"
            if ( sammler.indexOf("@") > -1 && sammler.indexOf("#") > sammler.indexOf("@") ) {

                // String zwischen '@' und '#' herausholen
                sammler = sammler.substring(1, sammler.indexOf("#"));
               
                // uebrig bleibt im Sammler nur die Zahl
                System.out.println(sammler);

                sammler = "";
            }

        } catch (SerialPortException ex) {
            System.out.println(ex);
        }
    }

    public static void main(String[] args) {
        new EinenAnalogWertInConsoleAusgeben();
    }
}


Ist dies geschehen, gibt es sicher einige rote Unterstreichungen im Quelltext.
Aber keine Panik! Es sind nämlich noch zwei Dinge zu erledigen:

1.    jssc - ein Java-Tool zur Datenübertragung

Für die Kommunikation über USB benutzen wir ein fertiges Programmpaket: "jssc - java simple serial connector".

Das kannst Du hier in deren Downloadabteilung herunterladen. Wähle dort einfach die letzte Version.

Nach dem Download entpackst Du die zip-Datei - es entsteht ein Ordner mit allerlei Dateien, wo Du z. B. die Lizenzbedingungen findest. Uns interessiert in erster Linie eine Datei namens jssc.jar, die Du später in Deinen Java-Projektordner legen kannst (oder wo immer Du sie haben willst).

Du musst die Datei jssc.jar mit einem Dateimanager Deines Betriebssystems (Windows-Explorer, Mac-Finder, Linux-Was-Weiß-Ich-Welchen-Dateimanager-Du-Benutzt) in den Projektordner Deines Arduino-Java-Projektes hineinkopieren.

Wenn Du jetzt in Eclipse im Package- oder im Projekt-Explorer mit rechts auf Dein Projekt klickst und "refresh" wählst, müsstest Du die Datei "jssc.jar" dort sehen.Rechtsklicke dort auf die Datei jssc.jar und wähle: Build Path --> zum Build Path hinzufügen.


2.    Dein serieller Port

Du musst im Programmcode unbedingt Deinen eigenen seriellen Port eintragen.
Der steht z. B. auf Deiner Arduino-IDE unten rechts und könnte z. B. in Windows  "COM3" sein oder bei einem Mac "/dev/tty.usbmodem24131".



Fertig!

Du kannst jetzt Dein Java-Programm starten (in Eclipse ist oben ein grüner Startknopf).
Du siehst dann in der Console von Eclipse die periodische Ausgabe der Zahlen:

       

Verändere die Stellung Deines einstellbaren Widerstandes - und die Zahl wird sich ändern!