Bluetooth – König Blauzahn verbindet

Inhaltsverzeichnis

Bluetooth-Boards gibt es inzwischen auch recht preisgünstig für Arduino-Controller und andere Microcontroller-Boards. Was liegt also näher als die bisher untersuchten Kommunikationsoptionen um Bluetooth zu ergänzen. Wie das ohne größere Hürden gelingen kann, ist Gegenstand dieser und der folgenden Ausgaben.

Für Kommunikation von Microcontroller zu Microcontroller, Desktop oder Mobilgerät im Umkreis von wenigen Metern eignet sich bekanntlich Bluetooth sehr gut. Daher liegt die Idee nahe, es auch in Arduino-Projekten zu nutzen. Wie üblich existieren dafür reichlich Alternativen an Boards oder Shields. Dazu später mehr.

Die vorliegenden Ausgabe des Blogs gibt einen Überblick und behandelt Bluetooth vor Version 4.0 bzw. BLE (Bluetooth Low Energy), während eine nachfolgende Ausgabe näher auf BLE eingeht.

Vorher sollten wir uns allerdings vergegenwärtigen, was Bluetooth bedeutet und wozu es gut ist.

Was ist überhaupt Bluetooth?

In Wikipedia findet sich dazu folgende Definition:

Bluetooth ist ein in den 1990er Jahren durch die Bluetooth Special Interest Group entwickelter Industriestandard gemäß IEEE 802.15.1 für die Datenübertragung zwischen Geräten über kurze Distanz per Funktechnik. Dabei sind verbindungslose sowie verbindungsbehaftete Übertragungen von Punkt zu Punkt und Ad-hoc- oder Piconetze möglich. Der Name „Bluetooth“ leitet sich vom dänischen König Harald Blauzahn (englisch Harald Bluetooth) ab, der verfeindete Teile von Norwegen und Dänemark vereinte. Das Logo zeigt ein Monogramm der altnordischen Runen für H und B.

Obwohl der Vergleich etwas hinkt, lässt sich Bluetooth ein wenig mit Internet-Protokollen vergleichen. So besitzen auch Bluetooth-Geräte eine MAC-Adresse von 48 Bits. Und wie bereits in der obigen Definition erwähnt, ermöglicht die Bluetooth-Protokollarchitektur sowohl verbindungsorientierte als auch verbindungslose Kommunikation. Ein Master nimmt dabei die Verbindung zu einem Slave auf.

Zu unterscheiden ist an dieser Stelle grundsätzlich zwischen Bluetooth vor Version 4.0 und Bluetooth Low Energy (ab Version 4.0). Die Versionen ab 4.0 erlauben wesentlich schnellere Kommunikation, bessere Fehlerkorrektur und Sicherheit (mit 128-Bit-AES-Verschlüsselung), sind dafür aber nicht abwärtskompatibel. Mitte 2016 wurde Bluetooth 5.0 vorgestellt, das die Reichweite gegenüber der aktuellen Version 4.2 vervierfacht und die Datenübertragungsrate verzweifacht.

Arduino @ Bluetooth im Überblick

Wer Bluetooth am Arduino verwenden möchte, hat die Qual der Wahl.

• Arduino-Boards wie das Intel-basierte Genuino/Arduino 101 mit integriertem Bluetooth sind a) noch selten und b) nicht gerade ein Schnäppchen. Darauf geht der vorliegende Beitrag nicht näher ein.

• HC-05/HC-06: Der Unterschied dieser sehr preisgünstigen Breakout-Boards mit Bluetooth 2.x Unterstützung besteht darin, dass der HC-05 mehr Fähigkeiten besitzt, etwa die, zwischen den Rollen von Master und Slave dynamisch zu wechseln. Breakout-Boards mit HC-05/HC-06 sind zum Beispiel auf ebay für Preise ab rund 5 bis 6 Euro zu haben. Da der HC-05 die Möglichkeiten des HC-06 mit abdeckt, rentiert es sich in vielen Fällen nicht, HC-06-Boards zu erwerben. Aus diesem Grund geht der Beitrag auch nur explizit auf den HC-05 ein. Wer über iOS-Geräte Bluetooth-Geräte ansteuern will, hat mit HC-05/HC-06 allerdings schlechte Karten. Dafür braucht es schon Bluetooth LE ab Version 4.0.

• HM-10: Der HM-10 mit seinem TI-cc2540-Chip und einer Unterstützung für Bluetooth 4.0 Low Energy gilt als Cousin der HC-05/HC-06-Angebote. Er ist für unter 10 Euro zu erwerben, weshalb dies die preisgünstigste Option darstellt, um BLE am Arduino zu integrieren.

• RedBearLab Bluetooth BLE Shield: Die Boards und Shields von RedBearLab wie das BLE-Nano oder das abgebildete BLE-fähige nRF51822-Shield bieten zum einen gute Qualität und zum anderen sehr gute Unterstützung. Allerdings hat Qualität bekanntlich ihren Preis und und schlägt im Falle des nRF51822-Shields mit bis zu 40 Euro zu Buche.

• Gar nicht aufgezählt sind hier zahlreiche weitere Bluetooth-Shields und -Boards. Insbesondere der mit Spannung erwartete ESP32 von Espressif als Nachfolger des ESP8266 dürfte mit seiner integrierten Bluetooth-LE-Unterstützung eine interessante Option darstellen. Den ESP32 behandelt der Blog in einer eigenen zukünftigen Ausgabe.

HC-05

Der oben vorgestellte HC-05 unterstützt Bluetooth V2.0 mit EDR (Enhanced Data Rate für dreifache Geschwindigkeit) auf einem 2,4-GHz-Band. Er integriert zahlreiche Ein- und Ausgänge und einen HCI-Port (Host Controller Interface) für serielle Kommunikation – beispielsweise über USB.

Ein entsprechendes Board enthält nebst den genannten Komponenten eine Antenne, das eigentliche Bluetooth-Modul, LEDs, einen Logic-Level-Shifter für 3,3 V/5 V, einen Spannungsregulator, 8 MByte Flash-Speicher und einen 26-MHz-Quarz.

Auf der abgebildeten Rückseite eines HC-05-Boards sind die nach außen geführten Ports zu erkennen. VCC und GND dienen der Stromversorgung, RXD und RXD zur seriellen Kommunikation. STATE zeigt an, ob es gerade eine aktive Verbindung des HC-05 gibt. KEY bzw. EN fungiert als Eingang, mit dessen Hilfe sich der Operations-Modus des HC-05 beeinflussen lässt. Das kommt weiter unten zur Sprache.

Wer sich weitere Informationen über den HC-05 holen möchte:

• Ein Datenblatt gibt es hier.
• Ein Benutzermanual ist hier verfügbar.
• Weitere Dokumente bietet die Produktseite auf dem LogicNeed-Store.

Schaltung mit HC-05

Besitzen Sie ein HC-05 Board mit 3,3-V-Logik ohne Logic-Level-Shifter, dürfen Sie HC-05 nicht direkt mit dem Arduino verbinden, sondern müssen zwischen beiden einen Logic-Level-Shifter mit 3,3 V auf der einen und 5 V auf der anderen Seite platzieren:

• Sie verbinden in diesem Fall den 5-V-Ausgang des Arduino mit dem 5-V-Eingang des Logic-Level-Shifters (HV), dessen 3,3-V-Ausgang (LV) Sie gleichzeitig mit dem 3,3-V-Spannungsausgang des Arduino verknüpfen.
• GND von Arduino und GND des HC-05 verbinden Sie entsprechend über den Logic-Level-Shifter.
• Den TX-Ausgang des Arduino verbinden Sie über einen Kanal auf der 5-V-Seite des Logic-Level-Shifters, während Sie den RX-Eingang des HC-05 an den entsprechenden Kanal auf der 3,3-V-Seite des Logic-Level-Shifters anschließen.
• Den RX-Eingang dex Arduino verbinden Sie über einen Kanal auf der 5-V-Seite des Logic-Level-Shifters, während Sie den TX-Ausgang des HC-05 an den entsprechenden Kanal auf der 3,3-V-Seite des Logic-Level-Shifters anschließen.

Es ergibt sich folgendes Schaubild in Fritzing:

Mini-Projekt als Beispiel

Um ein wenig mit der Kommunikation zwischen Arduino plus HC-05 auf der einen Seite und einem PC auf der anderen Seite zu experimentieren, soll folgendes Mini-Projekt helfen:

Über einen seriellen Monitor nimmt der Benutzer über Bluetooth eine Verbindung mit dem HC-05 auf, der mit einem Arduino verbunden ist. Ein Sketch auf dem Arduino liest die vom Benutzer empfangenen Daten am HC-05 und setzt sie in Befehle um. Erkennt der Arduino beispielsweise die Zeichenkette "ein", schaltet er die an Pin 13 befindliche LED an. Empfängt er "aus", schaltet der die LED entsprechend wieder aus. Zudem meldet der Arduino über HC-05 Nachrichten zurück, die wiederum drahtlos über Bluetooth zum Benutzer gelangen.

In der abgebildeten Schaltung ist der Arduino Uno mit dem HC-05 Breakout-Board verbunden. Die meisten Breakout-Boards integrieren einen Logic-Level-Shifter als Brücke zwischen 3,3-V- und 5-V-Welt, weshalb Maker sie direkt an den 5-V-Ausgang des Arduino-Boards anschließen können. Die Verbindung mit dem 3,3-V-Ausgang wie im unten abgebildeten Fritzing-Diagramm erweist sich daher in der Regel als unnötig.

Der Minischalter ist über den Spannungsausgang des Arduino mit dem KEY-Eingang des HC-05 verbunden, der oft auch anders benannt ist, etwa als EN. Teilweise befindet sich auf HC-05-Breakout-Boards aber bereits ein entsprechender Taster, sodass Maker ihn in der Schaltung weglassen können. Der Schalter dient jedenfalls dazu, zwischen den zwei Modi des HC-05 umzuschalten.

• Beim Verbinden des Breakout-Boards mit Versorgungsspannung ohne Betätigen des Tasters geht das Bluetooth-Modul in Betriebs- bzw. Verbindungsbereitschaft. In diesem Fall blinkt die Onboard-LED des Moduls sehr schnell.
• Erfolgt der Spannungsanschluss bei gedrücktem Taster wechselt das Modul in den AT-Befehlsmodus, der die interaktive Kommunikation und Konfiguration mit dem HC-05 ermöglicht. Zu erkennen ist der AT-Modus daran, dass die LED des Boards sehr langsam (alle zwei Sekunden) blinkt.

Am Digital-Ausgang 13 befindet sich in der Schaltung eine LED. Diese können genügsame Maker gerne weglassen, wenn ihnen stattdessen die Arduino-Uno-Onboard-LED reicht, die ebenfalls an diesem Ausgang liegt.

Der TX-Ausgang des HC-05 ist mit Digital-Port 10 des Uno verbunden, der RX-Ausgang des HC-05 mit Digital-Port 11 des Uno. Wie benutzen die Arduino-Pins 10, 11 in einem späteren Sketch als Software-basierten seriellen Bus, um mit dem HC-05 zu kommunizieren, weil wir den hardwaremäßigen seriellen Bus bereits für den seriellen Monitor benötigen.

Haben Sie ein Arduino-Board mit mehreren seriellen Bussen zur Verfügung wie einen Mega, können Sie natürlich auch einen der zusätzlichen Hardware-Ports Serial1 (RX1,TX1), Serial2 (RX2,TX2) oder Serial3 (RX3,TX3) verwenden.

In der folgenden Schaltung kommt ein HC-05 mit eingebautem Logic-Level-Shifter und Spannungsregulator zum Einsatz. Bei Breakout-Boards ohne diese Komponenten müssen Maker die Schaltung (wie weiter oben illustriert) um diese beiden Komponenten ergänzen.

Insgesamt ergibt sich an Verbindungen:

     Arduino                 HC-05
     3.3V                    VCC
     GND                     GND
     10 (oder RX1)           TX
     11 (oder TX1)           RX
     3.3V  über Taster mit   KEY

Sketch zur Interaktion mit HC-05/Arduino

Laden Sie folgenden Sketch auf den Uno. Der setzt im Übrigen genau den Anwendungsfall um, der eingangs beschrieben wurde, weshalb sich eine weiterführende Beschreibung erübrigt. Zudem sollte der verwendete Code selbsterklärend sein. Sollten Sie einen Mega verwenden und die TX/TX-Pins des HC-05 an Serial1 (RX1/TX1) des Mega angeschlossen haben, kommentieren Sie die Definition von softserial ein.

///////////////////////////////////////////////////
//
// Kleines interaktives Demo
// (c) 2016, Michael Stal
//  Nutzung:
//     Sketch auf Arduino laden
//     Bluetooth-Modul über Betriebssystem pairen
//     In Arduino IDE den Bluetooth-Port wählen
//        => Tools | Port
//     Dann Klick auf Sketchfenster, um Monitor
//     zu starten.
//     Im seriellen Monitor unten 38400 Baud
//     und "no line ending" einstellen
//     "ein" oder "aus" ins Textfeld eingeben, 
//     und LED beobachten.
//
///////////////////////////////////////////////////


// Wir verwenden Software Serial
#define softserial

// Eingebaute LED nutzen:
const int LED  = 13;


#ifdef softserial
  #include <SoftwareSerial.h>
  const int BTRX = 10;
  const int BTTX = 11;
  SoftwareSerial SerialBT(BTRX, BTTX);
#else 
  HardwareSerial SerialBT = Serial1;
#endif


// Die versendete Nachricht:
String msg; 


///////////////////////////////////////////////////
//
// setup
//    Verbindung mit HC-05 aufbauen
//
///////////////////////////////////////////////////

void setup() {
  SerialBT.begin(38400);
  SerialBT.println("Bluetooth-Verbindung steht");
  pinMode(LED, OUTPUT);
}

///////////////////////////////////////////////////
//
// loop
//    In jeder Iteration auf Nachricht warten,
//    Nachricht analysieren,
//    Aktion auslösen (LED ein/aus)
//
///////////////////////////////////////////////////

void loop() {
  if (SerialBT.available()){      // Daten liegen an
     msg = SerialBT.readString(); // Nachricht lesen
     if (msg == "ein") {
         digitalWrite(LED, HIGH);
         SerialBT.print("LED an Pin ");
         SerialBT.print(LED);
         SerialBT.println(" ist eingeschaltet!");
      } 
      else
      if (msg == "aus") {
         digitalWrite(LED, LOW);
         SerialBT.print("LED an Pin ");
         SerialBT.print(LED);
         SerialBT.println(" ist ausgeschaltet!");
      }
      else {
         SerialBT.print("Kommando ");
         SerialBT.print(msg);
         SerialBT.println(" nicht bekannt");
      }
    }
}                                                            

Nachdem der Sketch auf dem Arduino-Board erfolgreich geladen ist, navigieren Sie in Ihrem Betriebssystem zur jeweiligen Bluetooth-"Konsole".

• Die finden Sie zum Beispiel bei macOS rechts oben an der Desktop-Menüleiste. Dort gehen Sie auf Open Bluetooth Preferences ..., suchen nach dem HC-05 Board (meistens sehen Sie ein Gerät mit einem MAC-Code) und drücken auf Pair. Das geht schief, weshalb Sie über Options eine Dialogbox öffnen, den Code 1234 eingeben und auf Pair klicken.
• Unter Windows müssen Sie über Control Panel bzw. Einstellungen Hardware and Sound | Devices and Printers | Bluetooth Devices auf Add a Device klicken. Im nachfolgenden Dialogfenster wählen Sie die Option für die manuelle Eingabe des Pairing-Codes. Nun taucht das neue Bluetooth-Gerät auf, und Sie können über das Kontextmenü die COM-Portadresse des HC-05 ausfindig machen.

Anschließend gehen Sie in die Arduino IDE, wählen in Tools | Port den zugehörigen Bluetooth-Port, und klicken an einem Sketch-Fenster das Symbol zum Öffnen des seriellen Monitors. Dort geben Sie unten an der Fensterleiste "38400 Baud" als Geschwindigkeit ein und "no line ending". Nun können Sie über die Texteingabezeile Befehle versenden. "ein" schaltet die LED ein, "aus" schaltet sie aus.

Sie dürften Ähnliches wie auf dem folgenden Screenshot zu sehen bekommen:

AT-Kommandos

Bislang kam das HC-05-Breakout-Board in seiner Standardkonfiguration zum Einsatz. Was aber, wenn zum Beispiel eine Änderung der Baudrate erfolgen soll? Oder, wenn wir das Board wieder in seine Standardkonfiguration versetzen wollen?

Mit AT-Kommandos lässt sich ein HC-05 Board konfigurieren. Um in den AT-Modus des HC-05 zu gelangen, halten Sie den Schalter gedrückt, den wir in der oberen Schaltung eingefügt haben, während Sie Spannung an den Versorgungseingang des Breakout-Boards anlegen. Die LED des Boards beginnt langsam im Zweisekundentakt zu blinken.

Um das am Arduino Board angeschlossene HC-05-Board anzusprechen, verwenden wir den nachfolgenden Sketch.

Der macht nichts anderes als

• vom Arduino aus eine serielle Kommunikation mit dem Host-PC und ebenfalls eine serielle Verbindung zum HC-05 aufzubauen,
• in einer Schleife die Rückmeldungen des HC-05 am seriellen Monitor auszugeben und AT-Befehle des Benutzers im Terminal oder seriellen Monitor an den HC-05 weiterzuleiten.

Im seriellen Monitor oder dem Terminalprogramm sollten Maker als Baudrate 38400 festlegen, und dafür sorgen, dass der Monitor AT-Befehle am Ende mit den Zeichencodes für <Neue Zeile> und <Wagenrücklauf> versieht.

///////////////////////////////////////////////////
//
// HC-05 im AT-Modus ansteuern
// (c) 2016, Michael Stal
//  Nutzung:
//     Sketch auf Arduino laden
//     Seriellen Monitor aktivieren
//     Einstellung auf 38400 Baud
//     und Both CL & NR
//
///////////////////////////////////////////////////


// Für Nutzung von Serial1 am Mega 
// folgende Zeile einkommentieren:
#define softserial


#ifdef softserial
  #include <SoftwareSerial.h>
  const int BTRX = 10;
  const int BTTX = 11;
  SoftwareSerial SerialBT(BTRX, BTTX);
#else
  HardwareSerial SerialBT = Serial1;
#endif

void setup() {  
  Serial.begin(38400);    // Serieller Monitor
  SerialBT.begin(38400);  // Bluetooth / HC-05
  Serial.println("AT-Modus aktiv");
}

void loop() {  
  char c;
  // Liegen Daten (AT-Kommandos) am seriellen Monitor an?
  if (Serial.available()) { 
    c = Serial.read();  // Befehl lesen
    SerialBT.print(c);  // => an HC-05 senden
  }
  // Was liefert der HC-05 zurück?
  if (SerialBT.available()) {
    c = SerialBT.read(); // Meldung vom HC-05 lesen
    Serial.print(c);     // => am seriellen Monitor ausgeben   
  }
}

Nach Upload des Sketches und Aktivieren des seriellen Monitors habe ich zum Beispiel folgende AT-Kommandos an den HC-05 übermittelt:

AT                    Alles ok
AT+VERSION?           Version abfragen
AT+UART?              Einstellungen des seriellen UARTs abfragen
AT+PSWD?              Eingestellten Pairing-Code abfragen
AT+RESET              Board Reset
AT                    Siehe oben
AT+INIT               In Betriebsmodus wechseln

Im Ergebnis erhielt ich folgende Ausgabe:

Nach dem Befehl AT+INIT verlässt der HC-05 den AT-Modus und wechselt in den Betriebsmodus.

Sie können von AT-Kommandos nicht genug kriegen? Dann ist es jetzt an der Zeit, das PDF-Dokument mit den AT-Befehlen herunterzuladen.

Darf es etwas mehr sein?

Wer möchte, kann auch ein HC-05 in Kombination mit einem Prototyping-Shield zu einem Bluetooth Programming Shield verarbeiten. Falls Sie in der Arduino IDE oder der von Ihnen genutzten Programmierumgebung das serielle Bluetooth-Port angeben, unter dem Sie den HC-05 mit ihrem Betriebssystem ge-pairt haben, erfolgt der Sketch-Upload dann drahtlos über Bluetooth.

Autor Joshua Newell zeigt nähere Details dazu in seinem Make-Artikel, weshalb ich es mir spare, das alles nochmals zu wiederholen.

Fernsteuerung über Java

Bisher hat der Anwender Bluetooth auf dem Arduino mit dem seriellen Monitor angesprochen. In einem kleinen Experiment soll das Ganze jetzt programmatisch über Java geschehen. Wiederum muss als Beispiel ferngesteuertes Blinken der eingebauten LEDa des Arduino-Boards herhalten.

Dazu sollte der Maker zunächst den HC-05 mit AT-Kommandos konfigurieren, wie bereits früher erklärt.

Folgende Einstellungen kann der Entwickler im AT-Modus vornehmen:

• Um den HC-05 identifizieren zu können, empfiehlt sich ein einprägsamer Name: AT+NAME=<IhrWunschname>
• Den Pin-Code kann der Entwickler auf 0000 stellen, um nicht immer 1234 beim Pairing mit dem verwendeten Betriebssystem eingeben zu müssen: AT+PSWD=0000
• Die Kommunikationsparameter sind auf 9600-Baud, 1-Stopbit, kein Parity-Bit eingestellt: AT+UART=9600,1,0

Anschließend sollte der Maker den HC-05 wieder in den Betriebsmodus versetzen.

Der Arduino-Sketch ist ziemlich einfach. Er verwendet einen SoftwareSerial-Port oder alternativ einen HardwareSerial-Port (sofern verfügbar), über den sich das Arduino-Board mit dem HC-05 verbindet. Dabei nutzt der Sketch langsame 9600 Baud. Für ein Blink-Demo reicht das allemal.

In loop() liest der Sketch über HC-05/Bluetooth empfangene Zeichen und schaltet bei Empfang von "e" die Onboard-LED an Pin 13 ein, bei "a" aus – andere Zeichen ignoriert der Sketch einfach.

/////////////////////////////////////////
 //
 // Serielle Kommunikation über Bluetooth
 // HC-05 an Arduino
 //
 /////////////////////////////////////////

// define einkommentieren, um Serial1 
// am Mega zu verwenden:
#define softserial

#ifdef softserial
  #include <SoftwareSerial.h>
  const int BTRX = 10;
  const int BTTX = 11;
  SoftwareSerial SerialBT(BTRX, BTTX);
#else
  HardwareSerial SerialBT = Serial1;
#endif


// Verbindung zum angeschlossenen HC-05 aufbauen:
void setup() {
  SerialBT.begin(9600);
  pinMode(13, OUTPUT);
}

void loop() {
  // Einlesen, was der HC-05 über Bluetooth empfangen hat:
  char i= SerialBT.read();
  // e für einschalten =>
  if (i=='e') {
    digitalWrite(13, HIGH);  
  } 
  else
  // a für ausschalten  =>
  if (i == 'a') {
    digitalWrite(13, LOW);          
  }
}

Nun schauen wir uns die Java-Seite an.

Für das Java-Programm kommt die Bibliothek JSSC (Java-Simple-Serial-Connector) zum Einsatz. Deren aktuelle Version finden Sie zum Beispiel hier. Binden Sie die zugehörige JAR-Datei in ihr Projekt ein oder als externes JAR in den Java Build Path, falls Sie Eclipse benutzen.

Den im Code rot markierten seriellen Port müssen Sie durch Ihren eigenen ersetzen – der vom Autor voreingestellte Port befindet sich auf einem macOS-System, wobei der HC-05 zuvor per AT-Befehl den Namen MichaHC05-1 erhalten hat.

Vor Programmausführung sollte der Arduino-Sketch auf dem Arduino mit angeschlossenem HC-05 (im Betriebsmodus) laufen. Des Weiteren sollten Sie Betriebssystem und HC-05 ge-pairt haben.

Das Java-Programm öffnet über JSSC die Bluetooth-Verbindung zum HC-05, stellt die Kommunikationsparameter danach auf 9600 Baud, 8 Bits, 1 Stop-Bit, kein Parity-Bit ein. Anschließend wartet das Programm ein paar Sekunden, sollte der Arduino gerade am Reset sein. Danach sendet das Programm im Sekundentakt abwechselnd 'e' und 'a' an den HC-05, worauf das Arduino-Board die eingebaute LED an Pin 13 ein bzw. ausschaltet.

import jssc.SerialPort;
import jssc.SerialPortException;

///////////////////////////////////////////////////////
//
// Fernsteuerung eines Arduino mit HC-05
// 
///////////////////////////////////////////////////////

public class JavaSerial {
     public static void main(String[] args) {
     // Wartezeit in Sekunden, um auf Arduino zu warten
     final int SECS = 5;
     // Bluetoothverbindung aufbauen:
     SerialPort serialPort = new SerialPort("/dev/cu.MichaHC05-1-DevB");
        try {
               // Port öffnen:
               serialPort.openPort(); 
               System.out.println("Verbindung geöffnet");
               // Kommunikationsparameter einstellen:
               serialPort.setParams(SerialPort.BAUDRATE_9600, 
                                    SerialPort.DATABITS_8,
                                    SerialPort.STOPBITS_1,
                                    SerialPort.PARITY_NONE);
         
               // SECS Sekunden auf Arduino-Bereitschaft warten:
               for (int i = 0; i < SECS; i++) {
                  System.out.print(".");
                  Thread.sleep(1000); // 1 sec Pause
               } 
               System.out.println("... fertig");
            
               System.out.println("Und jetzt sende ich:");
               for (int i = 1; i <= 5; i++) {
                  System.out.println("Iteration " + i);
                  // e senden
                  serialPort.writeBytes("e".getBytes());
                  System.out.println("e (ein) gesendet");
                  Thread.sleep(1000);
                  // a senden
                  serialPort.writeBytes("a".getBytes());
                  System.out.println("a (aus) gesendet");
                  Thread.sleep(1000);
               }
               // Alle Schotten dicht:
               serialPort.closePort();
        }
        catch (SerialPortException ex) {
            System.out.println(ex);
        }
        catch (InterruptedException ex) {
            System.out.println(ex);
        }
     }
}

Natürlich lassen sich am Sketch einige Optimierungen vornehmen. Zum Beispiel könnte der Arduino-Sketch seine Empfangsbereitschaft kommunizieren, in dem er anfangs Daten an das Java-Programm sendet. Im Java-Programm wäre dann kein aktives Warten mehr erforderlich. Stattdessen würde das Java-Programm auf die Daten des Arduino warten, bevor es seinerseits Befehle an den Arduino sendet.

JSSC hat einen wesentlich größeren API-Umfang als das Beispiel vermuten lässt. So gibt es die Möglichkeit, Eventhandler zu definieren, wesentlich komplexere Daten zu versenden und empfangen, und weitere Parameter für die Kommunikation einzustellen. Maker können sich also nach Belieben austoben.

Alternativen

Da bekanntlich alle Wege nach Rom führen, gibt es natürlich Alternativen zur obigen Beispiellösung.

• In Java hätten wir auch die wesentlich umfangreichere RXTX-Bibliothek verwenden können. Die kam bereits in dieser Blog-Serie zum Einsatz.
• Python ermöglicht serielle Kommunikation mit Arduinos über pySerial und andere Bibliotheken wie zum Beispiel pyBluez.
• In JavaScript bieten sich mehrere Bibliotheken an, etwa node-bluetooth-serial-port für Node.js.

Zusammenfassung

Bluetooth ist ein allgegenwärtiger Industriestandard für Funkkommunikation, den heute alle Geräte, egal ob Desktops oder Mobilgeräte, unterstützen. Für Arduino bietet gerade der HC-05 eine unschlagbar günstige "Nachrüstoption". Mit seiner Hilfe können PCs oder Arduinos ihrerseits PCs oder Arduinos ansteuern. Anmerkung: Auch Android-Mobilgeräte lassen sich im Gegensatz zu ihren iOS-Pendants einbinden.

Der Beitrag hat gezeigt, was alles dafür notwendig ist, wobei sich der Aufwand durchaus in Grenzen hält.

Für größere Reichweiten, niedrigeren Energieverbrauch, und schnellere Übertragung gibt es mit Bluetooth Low Energy und Bluetooth ab Version 4.0, etwas aufwendigere Lösungen, die Maker dafür aber auch von iOS-Apps ansteuern können. Der Blog greift das spannende Thema daher in der nächste Folge auf. Bis dahin wünsche ich Ihnen viel Spaß beim kreativen Umsetzen der gezeigten Möglichkeiten. ()