Bluetooth: Auf den blauen Zahn gefühlt

Der Pragmatische Architekt  –  0 Kommentare

In der letzten Folge hieß das Thema "Bluetooth mit dem günstigen HC-05-Breakout-Board", das auf der Bluetooth-Version 2.0 basiert. In der neuen Folge geht es um Bluetooth 4.x Low Energy und das Breakout-Board HM-10. Auch BLE Shields mit ICs von Nordic Semiconductor wie die von RedBearLab oder Adafruit kommen kurz zur Sprache.

Eine grundlegende Einführung in Bluetooth enthielt bereits der letzte Artikel in dieser Reihe. An dieser Stelle soll es um die Grundlagen von Bluetooth 4.x gehen. Statt Bluetooth 4.x sind auch die Synonyme Bluetooth Low Energy (BLE) und Bluetooth Smart gebräuchlich.

Wie der Name BLE suggeriert, versucht sich diese Version an der Reduktion des Stromverbrauchs. In den Anfangszeiten von Bluetooth waren die Akkus mobiler Geräte in Windeseile entleert.

Als Bandbreite für Kommunikation benutzt BLE dank höherer Modulation 2 MHz statt der 1 MHz des klassischen Bluetooth. Seine Reichweite beträgt bei Mobilgeräten in der Regel bis 10 Meter. Zum Pairing benötigt es statt sechs Sekunden nur noch sechs Millisekunden, was einer Beschleunigung um den Faktor 1000 entspricht. BLE-Geräte eignen sich im Gegensatz zu Bluetooth BR/EDR (Basic Rate/Enhanced Data Rate) nicht für Anwendungen wie Audio-Streaming. Daher gibt es Dual-Mode-Geräte, die sich sowohl auf BLE als auch auf Bluetooth-BR/EDR verstehen.

Die Protokolle von Bluetooth 4.0 (siehe Abbildung) stellen sich wie folgt dar:

  • RF als Funk/Radio-Protokoll
  • Link Layer: Der Link Layer definiert Paketstrukturen und -kanäle, Discovery- und Verbindungsprozeduren, und sorgt für Senden und Empfangen von Daten.
    • LC als Link Control Protocol.
    • LM als Link Manager Protocol.
    • L2CAP (Logical Link Control and Adaptation Protocol). Es ist paketbasiert und sendet Pakete an das Host-Controller Interface (siehe unten) oder direkt an den Link Manager in einem System ohne Host. Es unterstützt Multiplexing auf höherer Protokollebenen, Paketsegmentierung und -zusammenfügung sowie die Vermittlung von Quality-of-Service-Information,

Die drei letztgenannten Layer der Protokollschicht firmieren auch als Bluetooth Controller. Als Schnittstelle zwischen Controller und Host dient das optionale HCI (Host-Controller-Interface), wobei der Host einfach den Rest des Bluetooth-Systems darstellt.

Er besteht aus:

  • Security Manager – liefert Protokoll und Verhalten, um die Integrität des Pairing sicherzustellen sowie um für Authentifizierung und Verschlüsselung zu sorgen.
  • ATT (Attribute Protocol) – spezifiziert die Client/Server-Interaktion für Datenaustausch, sobald die Verbindung steht. Attribute werden dank des GATT zu sinnvollen Diensten gruppiert. ATT unterscheidet Server (Gerät, das Daten enthält) und Client (Gerät, das Daten von einem Server liest).
  • GATT (Generic Attribute Profile) – gruppiert Dienste (Verhalten). Beispiele: Find Me Profile, Proximity Profile, HID Profile (Tastaturen, Mäuse, Fernbedienungen), Glucose Profile, Health Thermometer Profile, Cycling Speed and Cadence Profile. Es gibt zudem herstellerspezifische Profile wie zum Beispiel Apples iBeacon.
  • GAP (Generic Access Profile) – definiert in Kombination mit GATT Prozeduren und Rollen, um Bluetooth-Geräte zu finden, Informationen auszutauschen und das Verbindungsmanagement umzusetzen. Eine Rolle ist zum Beispiel das Peripheral, sprich ein Gerät, das seine Dienste anderen Geräten über sogenannte Advertisements anbieten kann, während sich nur ein Central Device mit dem Peripheral verbinden darf. Eine spezielle Art von Central stellt der Observer dar, der die Umgebung nach Advertisements von BLE-Geräten scannt. Ein Broadcaster als spezielle Art eines Peripherals versendet hingegen Advertisements.
  • Der Bluetooth 4.0 Stack (Bild: bluetooth.com)

Zwei in diesem Zusammenhang häufig auftretende Begriffe sind Piconets und Scatternets. Piconet bedeutet, dass sich bis zu acht Geräte unter Verwendung eines 3-Bit-Adressierungschema zu einem lokalen Netzwerk verbinden können. Ein Gerät fungiert dabei als Master und definiert die Parameter der gemeinsamen Kommunikation, während die anderen ein bis maximal sieben Geräte als Slaves fungieren. Mehrere unabhängige Piconets zusammen können ein Scatternet bilden, wenn ein Gerät als Mitglied in allen beteiligten Piconets die Rolle des Gateway übernimmt. Dieses Gateway kann allerdings in maximal einem der Piconets die Rolle des Masters besitzen.

Shields wie das BLE Shield von RedBearLab basieren auf dem Chip nRF8001 von Nordic Semiconductor. Auf denselben Chip baut auch das Adafruit Bluefruit LE Board auf. Neuere Boards verwenden inzwischen den Nachfolger-Chip von Nordic Semiconductor namens nRF51822, etwa das abgebildete ReadBearLab nRF51822 Shield.

RedBearLab Bluetooth Low Energy Shield mit nRF51822 on Board (Bild: RedBearLab.com)

Oder zum Beispiel das Breakout-Board Adafruit Bluetooth LE SPI Friend:

ADAFRUIT BLUEFRUIT LE SPI FRIEND - BLUETOOTH LOW ENERGY (BLE) (Bild: adafruit.com)

Für diese BLE Boards bieten die Hersteller sowohl Bibliotheken zur Arduino-Programmierung als auch Apps für iOS und Android. Allerdings sind diese Produkte relativ teuer, weshalb sie nur am Rande Erwähnung finden sollen.

Nach diesem kurzen Überblick möchte ich mich jetzt dem HM-10 als preisgünstige Alternative zuwenden.

Vom HM-10 hatten wir bereits im Überblicksteil der letzten Blogfolge gehört. Dieser jüngere Bruder des HC-05 versteht sich auf Bluetooth 4.0 Low Energy. Zudem zeichnen sich entsprechende Boards durch einen angenehmen Preis ab 5 bis 6 Euro bei ebay aus. Wer noch mehr sparen möchte und über ausreichend Vertrauen und Geduld verfügt, kann freilich auch zu Preisen unter 3 Euro bei chinesischen Anbietern fündig werden. Ratsam ist es in der Regel nicht, zumal sich Klone nicht in jeder Beziehung wie Original-Breakout-Boards verhalten. Auf jeden Fall können HM-10-Boards sowohl die Rolle Central als auch die Rolle Peripheral annehmen, wie beim GAP (Generic Access Profile) beschrieben.

Auf den ersten Blick unterscheidet sich ein HM-10 äußerlich kaum von einem HC-05.

Das HM-10 Board versteht sich auf Bluetooth Low Energy (Bild: mikrocontroller-praxis.de)

Die nach außen geführten Pins entsprechen denen des HC-05, wenn gleich bei Original-Boards in umgekehrter Reihenfolge:

       STATE                    Ausgang => Verbindungsstatus
RXD
Eingang für serielle Kommunikation
TXD
Ausgang für serielle Kommunikation
GND
Erde
VCC
Versorgungsspannung
BRK oder KEY oder EN
Eingang Verbindungen unterbrechen bei
Low-Signal

Ein HC-05 lässt sich daher relativ einfach mit einem HM-10 ersetzen. Unter dessen Haube schlummert ein Texas Instruments CC2540 oder bei neueren Varianten ein CC2541-Chip mit Bluetooth 4.0 BLE Unterstützung (=> Datenblatt).

Pinout des HM-10 Boards

Achtung: Der HM-10 benötigt 3,3 V Versorgungsspannung. Sollte das genutzte Breakout-Board über keinen Logik-Level-Shifter sowie einen 3,3-V-Spannungsregulator verfügen, schließen Sie das Board entsprechend an den Arduino-3,3-V-Ausgang an und verwenden Sie einen Logic-Level-Shifter.

Die Schaltung mit Arduino Uno und HM-10 schaut unter diesen Voraussetzungen folgendermaßen aus:

in Logic Level Shifter verbindet Uno und HM-10 Board

Der Aufwand mit Logic-Level-Converter ist nicht notwendig, sollten Sie ohnehin ein Arduino-Board verwenden, das mit 3,3-V-Logik arbeitet.

Um den AT-Kommando-Modus HM-10 zu nutzen, lässt sich folgender Sketch verwenden. Im Beispiel kommt ein serieller Software-Port mit den Digital-Pins 10 und 11 zum Einsatz.

// In diesem Beispiel verwenden wir die
// Pins 10, 11 als seriellen Software-Port


#include <SoftwareSerial.h>

#define softRX 10
#define softTX 11

SoftwareSerial softSerial(softRX, softTX);
char c;

void setup() {
Serial.begin(9600); // Serieller Monitor
softSerial.begin(9600); // Verbindung zu HM-10
Serial.println("AT-Kommando-Modus => ");
}

void loop() {
// Meldungen vom HM-10 lesen und
// am seriellen Monitor ausgeben

while (softSerial.available()) {
c = softSerial.read();
Serial.print(c);
}

// AT-Kommandos vom seriellen Monitor
// lesen und zum HM-10 übermitteln

while (Serial.available()) {
c = Serial.read();
Serial.print(c);
softSerial.print(c);
}
}

Bei Eingabe von AT + HELP geben Boards mit CC2541-Chip oft die Liste der unterstützten AT-Befehle zurück:

HM-10 im AT-Modus

Die HM-10-Original-Module von JN HuaMao benötigen übrigens kein NL+CR im seriellen Monitor, Klone hingegen meistens schon.

Kleiner Tipp am Rande: Wenn Sie ein wenig mit dem AT-Modus des HM-10 experimentieren, könnte es passieren, dass das Board nicht mehr reagiert, weil Sie es in versehentlich in den Schlaf-Modus versetzt haben. In diesem Fall geben Sie am seriellen Monitor eine Zeichenkette mit über 80 Zeichen ein, worauf das Board mit Ausgabe von OK + Wake reagiert.

Um zu experimentieren, greift der Beitrag noch mal das interaktive Beispiel vom vorherigen Blog-Posting auf, bei dem es um entfernte Interaktion über HM-10 und mit dem Arduino ging.

Eine App, im Falle des Autors die iOS-App HM10 Bluetooth Serial, erlaubt das Übermitteln von Textbefehlen an den Sketch, der den Befehl interpretiert, bei "ein" die Onboard-LED einschaltet, sie bei "aus" ausschaltet und ansonsten einen unbekannten Befehl an die App zurückmeldet.

HM10 Bluetooth Serial App für iOS-Geräte

Der Sketch – eine leicht abgewandelte Variante des Sketches der letzten Folge – schaut folgendermaßen aus:

//////////////////////////////////////////////////
//
// Kleines interaktives Demo
// (c) 2016, Michael Stal
// Nutzung:
// Sketch auf Arduino laden
// An Arduino HM-10 anschließen
//
// Über BLE App serielle Verbindung aufbauen,
// "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 HM-10 aufbauen
//
///////////////////////////////////////////////////


void setup() {
SerialBT.begin(9600);
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");
}
}
}

Im Gegensatz zum HC-05-Modul war ein explizites Pairing mit dem Betriebssystem nicht notwendig. Die App erlaubt die direkte Kontaktaufnahme zum HM-10, nachdem sie das BLE-Modul über einen Scan gefunden hat.

Hier ein Screenshot der Interaktion zwischen iPad und Arduino/HM-10: Zuerst wird die LED eingeschaltet, danach ausgeschaltet und anschließend ein unbekannter Befehl versandt:

HM10 Bluetooth Serial App für iOS im Zusammenspiel mit Arduino + HM-10

Für andere Betriebssysteme sowie für Android oder Windows Phone existieren ebenfalls entsprechende Apps.

Haben Sie ein Breakout-Board mit CC2541 erworben, das kein Original von JN HuaMao darstellt, können Sie trotzdem das Board durch Überspielen der Firmware wie das Original nutzen. Selbstredend bleibt dadurch die Hardware Ihres Klons dieselbe. Ein wertiges Original lässt sich so also nicht erzeugen. Aber sei's drum. Zumindest verhält sich die Firmware identisch. Insofern lohnt sich der Aufwand.

Was Sie benötigen:

Vorgehen:

  1. Die Pins 7, 8, 11 des HM-10-Klonboards (linke Reihe des Boards von links oben gezählt) verbinden Sie mit den digitalen Arduino Uno Pins 5, 6, und 4. Dazu löten Sie Schaltdraht an die entsprechenden Ports Ihres HM-10-kompatiblen Boards.
  2. Zusätzlich versorgen Sie das Breakout-Board mit 3,3 V und GND des Arduino.
  3. Den Sketch CCloader.ino übertragen Sie auf das Arduino-Board. Merken Sie sich den COM-Port, über den Sie den Arduino angeschlossen haben. Bei mir ist es COM16.
  4. Öffnen Sie die Kommandokonsole (cmd) unter Windows und navigieren Sie zu dem Verzeichnis, in dem sowohl das Programm CCLoader.exe als auch die Firmwaredatei CC2541xxxxxxx.bin liegen.
  5. Nun geben Sie folgenden Befehl ein: CCLoader <port> <firmware> 0. Bei meinem Windows-Notebook lautet der USB-Port COM16, und die Firmware-Datei CC2541hm10v540.bin. Dazu benutze ich ein Uno-Board, sodass der Aufruf wie folgt lautet (bei einem Leonardo geben Sie anstelle der 0 eine 1 als letzten Parameter ein): CCLoader 16 CC2541hm10v540.bin 0

Anschließend zählt der Sketch bis 512 (Zahl der übertragenen Firmware-Datenblöcke), und Sie verfügen danach über ein Breakout-Board mit Original-Firmware.

Achtung: Es ist nicht garantiert, dass dieses Vorgehen bei allen Breakout-Boards mit CC5241 funktioniert. Erfolgreich getestet hat es der Autor mit einem CC2541-Board von Bolutek.

Als weiteren Anwendungsfall stellt der Beitrag nun die Kommunikation zweier Arduino-Boards mit angeschlossenem HM-10 vor. Einsatz finden im konkreten Fall ein Uno und ein Leonardo-Board. Das Uno-Board soll als Master dienen, das Leonardo-Board als Peripheral. In beiden Fällen verwenden wir Softserial als serielle Schnittstelle zur Kommunikation mit dem HM-10. Die HM-10-Boards benutzen die Original-Firmware, so wie sie im letzten Abschnitt aufgespielt wurde.

Um die Boards zu initialisieren, müssen Maker die HM-10-Boards in den AT-Modus versetzen. Der bereits wiederholt dafür verwendete Sketch ist zur Übersicht nochmals abgebildet. Es empfiehlt sich, zunächst beide Boards mit At + Renew auf Factory-Settings zurückzusetzen.

#include <SoftwareSerial.h>
SoftwareSerial SerialBT(10, 11);

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

void loop() {
char c;
if (Serial.available()) {

c = Serial.read();
SerialBT.print(c);
}
if (SerialBT.available()) {

c = SerialBT.read();

Serial.print(c);
}
}

Lassen Sie sich vom HM-10 am Leonardo-Board mittels At + Addr? die MAC-Addresse 0x00XXXXXXXXXX zurück liefern.

Auf den Leonardo überspielen wir den inzwischen sattsam bekannten Sketch zur LED-Ansteuerung, der sich ohne Kommentare wie folgt darstellt:


#include <SoftwareSerial.h>

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

const int BTRX = 10;
const int BTTX = 11;
SoftwareSerial SerialBT(BTRX, BTTX);

String msg;

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

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.println(msg);
}
}
}

Den am Uno hängenden HM-10 spezifizieren Sie mittels At + Role1 als Master. Zudem bauen Sie eine Bluetooth-Verbindung zum Leonardo auf: At+Con00XXXXXXXXXX.

Anschließend leuchten die LEDs an beiden HM-10-Boards permanent.

Wenn Sie über den mit dem Uno+HM-10 verbundenen seriellen Monitor Kommandos wie "ein", "aus" eingeben, sendet dieser die Kommandos über Bluetooth an den Leonardo weiter, dessen eingebaute LED an Port 13 entsprechend reagiert.

Selbstredend könnten wir jetzt statt des Sketches für den At-Modus auch beliebige andere Sketche am Uno nutzen, um den Leonardo+HM-10 über Bluetooth anzusprechen.

In dieser und der letzten Folge ging es um den Einsatz von Bluetooth-Kommunikation mit Arduino-Boards. Neben preislich gehobeneren Lösungen wie den Shields auf Basis der Nordic-Semiconductor-Lösungen nRF8001 und nRF51822 haben die Beiträge auch die preisgünstigen Breakout-Boards HM-10 (Bluetooth Low Energy) und HC-05 (Bluetooth 2.x) adressiert.

Der Einsatz von Bluetooth eignet sich im Wesentlichen für drei Einsatzzwecke: für die Fernsteuerung von am Arduino angeschlossener Sensoren und Aktoren, für den drahtlosen Upload von Sketches auf Arduino-Boards, und für die Peer-to-Peer-Kommunikation zwischen Arduino-Boards.

Vielversprechend sind Chips und darauf aufbauende Boards, die neben Bluetooth 4.x auch WiFi unterstützen. Insbesondere vom ESP-32 (Espressif) wird in Zukunft noch die Rede sein.