Was ist die Arduinospielwiese?


Was brauchst Du?


Experimente &
Projekte


Downloads &
Links


häufige Fragen

Impressum

Wie geht serielle Datenübertragung mit Java? (neue 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 (hier: JSlider mit Skalen) 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 jSerialCom 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 MacOS läuft.

Für andere Java-Programmierfreunde ist Netbeans oder IntelliJ 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 com.fazecast.jSerialComm.SerialPort;


// Vom Arduino wird seriell sekündlich ein String in 
// der Form: @wert# gesendet, wobei wert = [0, 1023] ist.
//	
// Dies geschieht, damit in der Auswertung des Wertes Steuerzeichen
// und Datenmüll weggefiltert werden können.


public class EinenAnalogWertInConsoleAusgeben {

 // globale Variablen:
 SerialPort mySerialPort;
 String empfangenerString = "";

 // Constructor:
 public EinenAnalogWertInConsoleAusgeben() {
		verbindung_herstellen();
 }

 public void verbindung_herstellen() {

	// an welchem Port hängt ARDUINO? (Win10 - auch Mac & Linux?)
	SerialPort[] availablePorts = SerialPort.getCommPorts();

	// den ersten gefundenen Port benutzen:
	mySerialPort = availablePorts[0];
	
	int BaudRate = 9600;
	int DataBits = 8;
	int StopBits = SerialPort.ONE_STOP_BIT;
	int Parity = SerialPort.NO_PARITY;

	mySerialPort.setComPortParameters(BaudRate, DataBits, StopBits, Parity);

	mySerialPort.setComPortTimeouts(SerialPort.TIMEOUT_READ_BLOCKING, 1000, 0);

	mySerialPort.openPort(); // Aduino erhält dabei RESET

	// Pause, damit Arduino nach RESET wieder "da" ist
	try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	// Test, ob obiger Port geöffnet ist:
	if (mySerialPort.isOpen())
		System.out.println(mySerialPort + " is open");
	else
		System.out.println("Port not open");

	try {
	  while (true) {

		byte[] readBuffer = new byte[100];

		mySerialPort.readBytes(readBuffer, readBuffer.length);

		// Konvertiere Bytes zu String
		String empfangenerString = new String(readBuffer, "UTF-8");

		// Test auf Vorhandensein von vorn "@" und hinten "#"
		if (empfangenerString.indexOf("@") > -1  
			&& empfangenerString.indexOf("#") > -1
			&& empfangenerString.indexOf("#") > 
			                         empfangenerString.indexOf("@")) {

			empfangenerString = empfangenerString.replaceAll("null", "");
			empfangenerString = empfangenerString.replaceAll("\n", "");
			empfangenerString = empfangenerString.replaceAll("\r", "");

			// String zwischen '@' und '#' herausholen
			empfangenerString = 
			   empfangenerString.substring(1, empfangenerString.indexOf("#"));

			System.out.println(empfangenerString);
		}
	  }
	} catch (Exception e) {	e.printStackTrace(); }
 }

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

}

Ist dies geschehen, gibt es sicher einige rote Unterstreichungen im Quelltext.
Aber keine Panik! Es ist nämlich noch ein Werkzeug zur seriellen Kommunikation zu installieren:

jSerialComm - ein Tool zur seriellen Datenübertragung

Für die Kommunikation über USB benutzen wir ein fertiges Programmpaket: "jSerialComm-2.9.3.jar".
(2.9.3 war die aktuelle Version im Mai 2023).

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

Nach dem Download entpackst Du die zip-Datei (wenn eine vorhanden ist) - es entsteht ein Ordner mit allerlei Dateien, wo Du z. B. die Lizenzbedingungen findest. Uns interessiert in erster Linie eine Datei namens jSerialComm-2.9.3.jar, die Du später in Deinen Java-Projektordner legen kannst.

Du musst die Datei jSerialComm-2.9.3.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 "jSerialComm-2.9.3.jar" dort sehen. Rechtsklicke dort auf die Datei jSerialComm-2.9.3.jar und wähle: Build Path --> zum Build Path hinzufügen (englisch: Add to Buildpath).


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!   .