Bluetooth-Modul JDY-18, BLE 4.2, UART-Schnittstelle, Reichweite 60 m

Dieses Tutorial verwendet das Arduino Uno R3 Board, um das Modul JDY-18 in Betrieb zu nehmen, ein Bluetooth-Low-Energy-Modul (BLE) 4.2 mit serieller UART-Schnittstelle. Das Modul benötigt kein eigenes Programm, braucht aber einen Mikrocontroller, der mit ihm über die serielle Schnittstelle kommuniziert, und dafür reicht das Arduino Uno aus. Sie setzen es in Projekten ein, die Daten an ein Smartphone senden oder Befehle von diesem empfangen, etwa bei Fernbedienungen, drahtlosen Sensoren oder batteriebetriebenen Geräten.

So funktioniert es:

Das Modul besitzt einen eigenen Funkprozessor und erscheint im Smartphone als BLE-Gerät. Nach dem Verbinden transportiert ein Dienst mit der UUID FFE0 und einer Charakteristik FFE1 die Daten in beide Richtungen. Alles, was das Smartphone auf die Charakteristik FFE1 schreibt, kommt am TXD-Pin des Moduls heraus, und alles, was am RXD-Pin eintrifft, gelangt zum Smartphone. Man nennt dies transparente Übertragung, da das Modul den Inhalt der Daten nicht verändert.

Werkseitig arbeitet das Modul als Slave-Gerät (AT+HOSTEN0), mit der seriellen Geschwindigkeit von 9600 Baud (AT+BAUD4) und dem Namen JDY-18. Bei 9600 Baud benötigt ein Byte etwa 10 Bit (Start, 8 Datenbits, Stopp), sodass sich etwa 960 Byte pro Sekunde zwischen Arduino und Modul übertragen lassen. Funkseitig arbeitet das Modul mit 2.4 GHz, mit einer Sendeleistung von maximal 0 dBm und einer Reichweite von bis zu 60 m im freien Feld.

Das Modul akzeptiert nur niedrige Spannung, daher wird es über den Pin 3.3V des Uno-Boards versorgt. Die Signale des Arduino Uno haben 5 V, während der RXD-Eingang des Moduls für 3.3 V ausgelegt ist. Deshalb wird zwischen D3 und RXD ein Spannungsteiler aus zwei Widerständen gesetzt, R1 mit 1 kΩ in Reihe und R2 mit 2 kΩ gegen GND. Die Spannung am RXD ergibt sich aus der Formel Vout = 5 V x 2 kΩ / (1 kΩ + 2 kΩ) = 3.33 V. In umgekehrter Richtung hat der TXD-Ausgang des Moduls 3.3 V, ein Pegel, den der Arduino Uno korrekt als logische 1 erkennt, daher wird TXD direkt mit D2 verbunden.

Das Modul verbraucht etwa 4 mA im wachen, sendenden Zustand, unter 300 µA im Leichtschlaf und etwa 1.8 µA im Tiefschlaf. Der Pin 3.3V des Uno-Boards kann bis zu 50 mA liefern, das reicht also aus.

Anschluss:

Trennen Sie das Uno-Board vom USB-Kabel, bevor Sie die Verbindungen herstellen. Versorgen Sie das Modul nur über den Pin 3.3V, niemals über 5V, da 5 V die Schaltung zerstören können. Die fünf Pins des Moduls sind auf der Rückseite der Platine beschriftet, prüfen Sie also die Aufdrucke vor dem Anschließen, da die Pinreihenfolge von Charge zu Charge abweichen kann. Der Pin STAT bleibt in diesem Tutorial unbeschaltet. Wir verwenden SoftwareSerial an den Pins D2 und D3, sodass der Hardware-Serialport für den Seriellen Monitor frei bleibt.

Board und Bibliotheken:

Wählen Sie in der Arduino IDE Werkzeuge > Board > Arduino AVR Boards > Arduino Uno. Das Paket Arduino AVR Boards ist bereits in der Arduino IDE enthalten, daher muss es nicht separat über die Boardverwaltung installiert werden. Das Programm verwendet nur die Bibliothek SoftwareSerial, die in der Arduino IDE enthalten ist, daher muss keine Bibliothek über die Bibliotheksverwaltung installiert werden.

Der Code:

Das Programm sendet beim Start einige AT-Befehle, um die Verbindung zum Modul zu prüfen, und verbindet danach den Seriellen Monitor in beide Richtungen mit dem Modul, sodass Sie AT-Befehle senden oder die vom Smartphone empfangenen Daten sehen können.

/*
  JDY-18 BLE module test on Arduino Uno
  Board: Arduino Uno (Tools > Board > Arduino AVR Boards > Arduino Uno)
  Board package: Arduino AVR Boards (comes with the Arduino IDE)
  Libraries: SoftwareSerial (included in the Arduino IDE), nothing to install
  Wiring:
    JDY-18 VCC -> Arduino 3.3V (never 5V)
    JDY-18 GND -> Arduino GND
    JDY-18 TXD -> Arduino D2 (SoftwareSerial RX)
    JDY-18 RXD -> R2 2 kOhm to GND, and R1 1 kOhm to Arduino D3 (SoftwareSerial TX)
    The R1 / R2 divider lowers the 5 V of D3 to about 3.3 V for the module.
  Serial Monitor: 9600 baud, line ending "Both NL & CR".
*/
#include <SoftwareSerial.h>
const byte BT_RX_PIN = 2;  // Arduino receives here (connected to module TXD)
const byte BT_TX_PIN = 3;  // Arduino transmits here (to module RXD via divider)
SoftwareSerial bt(BT_RX_PIN, BT_TX_PIN);  // Software serial port for the module
// Sends one AT command and prints the answer on the Serial Monitor
void sendCommand(const char *command) {
  Serial.print("> ");
  Serial.println(command);
  // Throw away any old data in the receive buffer
  while (bt.available()) {
    bt.read();
  }
  // The module needs every AT command to end with \r\n
  bt.print(command);
  bt.print("\r\n");
  // Read the answer until the module is silent for 500 ms
  unsigned long lastByteTime = millis();
  char lastChar = '\n';
  while (millis() - lastByteTime < 500) {
    while (bt.available()) {
      lastChar = (char)bt.read();
      Serial.write(lastChar);
      lastByteTime = millis();
    }
  }
  // Make sure the next output starts on a new line
  if (lastChar != '\n') {
    Serial.println();
  }
}
void setup() {
  Serial.begin(9600);  // Serial Monitor speed
  bt.begin(9600);      // Factory baud rate of the JDY-18
  delay(500);          // Give the module time to start
  Serial.println("JDY-18 test started");
  // Basic queries, accepted while no phone is connected
  sendCommand("AT+VERSION");  // Firmware version
  sendCommand("AT+NAME");     // Advertised name
  sendCommand("AT+BAUD");     // Baud rate code
  sendCommand("AT+LADDR");    // Bluetooth MAC address
  Serial.println("Bridge ready. Type AT commands or connect from a phone.");
}
void loop() {
  // Module -> Serial Monitor (AT answers or data sent by the phone)
  if (bt.available()) {
    Serial.write(bt.read());
  }
  // Serial Monitor -> module (AT commands or data for the phone)
  if (Serial.available()) {
    bt.write(Serial.read());
  }
}

So funktioniert der Code:

Zu Beginn legen die Konstanten BT_RX_PIN und BT_TX_PIN die Pins D2 und D3 fest, und das Objekt bt vom Typ SoftwareSerial erzeugt an diesen Pins einen softwareseitigen seriellen Port. BT_RX_PIN ist der Pin, an dem der Arduino die Daten vom TXD des Moduls empfängt, und BT_TX_PIN ist der Pin, an dem der Arduino Daten über den Teiler an den RXD des Moduls sendet.

Die Funktion sendCommand() erhält einen AT-Befehl als Text, gibt ihn im Seriellen Monitor mit dem Präfix "> " aus und leert den Empfangspuffer, damit sich keine alten Antworten mit der neuen vermischen. Danach sendet sie den Befehl gefolgt von \r\n, da das Modul diesen Abschluss bei jedem Befehl verlangt. Anschließend liest sie die Antwort und kopiert sie in den Seriellen Monitor, bis das Modul 500 ms lang still bleibt. Zum Schluss fügt die Funktion, falls das letzte Zeichen kein Zeilenumbruch war, einen hinzu, damit die nächste Ausgabe in einer eigenen Zeile beginnt.

In setup() wird der Serielle Monitor mit 9600 Baud gestartet, ebenso der Port bt mit 9600 Baud, der werkseitigen Geschwindigkeit des Moduls. Nach einer Pause von 500 ms, in der das Modul hochfährt, gibt das Programm die Startmeldung aus und sendet vier Abfragen: AT+VERSION für die Firmware-Version, AT+NAME für den gesendeten Namen, AT+BAUD für den Code der seriellen Geschwindigkeit und AT+LADDR für die Bluetooth-MAC-Adresse.

In loop() arbeitet das Programm als serielle Brücke. Jedes Byte, das vom Modul empfangen wird, wird auf den Seriellen Monitor geschrieben, und jedes Byte, das Sie im Seriellen Monitor eingeben, wird an das Modul gesendet. So können Sie AT-Befehle von Hand eingeben oder den vom Smartphone gesendeten Text verfolgen.

Ergebnis:

Öffnen Sie den Seriellen Monitor mit 9600 Baud und wählen Sie den Zeilenendeschalter "Sowohl NL als auch CR". Nach einigen Sekunden erscheinen die Antworten des Moduls auf die vier Abfragen und danach die Meldung, dass die Brücke bereit ist. Die genauen Werte können abweichen, besonders die MAC-Adresse.

JDY-18 test started
> AT+VERSION
+JDY-18-V1.5
> AT+NAME
+NAME=JDY-18
> AT+BAUD
+BAUD=4
> AT+LADDR
+LADDR=A4C138112233
Bridge ready. Type AT commands or connect from a phone.

Um die Verbindung zum Smartphone zu testen, öffnen Sie eine BLE-Terminal-App, verbinden Sie sich mit dem Gerät JDY-18, aktivieren Sie die Benachrichtigungen für die Charakteristik FFE1 und senden Sie einen Text. Der Text erscheint im Seriellen Monitor. Was Sie nach dem Verbinden im Seriellen Monitor eingeben, gelangt in die App.

Häufige Probleme:

Auf AT-Befehle kommt keine Antwort. Die häufigste Ursache ist das Vertauschen von TXD und RXD oder ein falscher Zeilenendeschalter. Prüfen Sie, dass TXD an D2 und RXD über den Teiler an D3 angeschlossen ist, und wählen Sie im Seriellen Monitor "Sowohl NL als auch CR". Prüfen Sie außerdem die Geschwindigkeit von 9600 Baud.

Die Antworten erscheinen mit seltsamen Zeichen. Die serielle Geschwindigkeit des Moduls wurde geändert oder der Serielle Monitor ist falsch eingestellt. Stellen Sie den Seriellen Monitor auf 9600 Baud ein, und wenn Sie die Geschwindigkeit des Moduls mit AT+BAUD geändert haben, verwenden Sie denselben Wert in bt.begin().

AT-Befehle werden nicht akzeptiert. Solange ein Smartphone verbunden ist, behandelt das Modul die Daten als transparente Daten. Trennen Sie das Smartphone oder halten Sie den Pin PWRC auf Low-Pegel, falls Sie ihn für eine eigene Verbindung herausgeführt haben.

Das Modul erscheint nicht in der Liste des Smartphones. Prüfen Sie die Versorgung über den Pin 3.3V und die gemeinsame Masse. Suchen Sie das Gerät mit einer BLE-App und nicht in der klassischen Bluetooth-Liste des Smartphones, da JDY-18 nur BLE verwendet.

Das Modul wird warm oder antwortet nach dem Verbinden nicht mehr. Möglicherweise wurde es mit 5 V versorgt oder es hat ein 5-V-Signal direkt am RXD erhalten. Prüfen Sie den Teiler aus R1 und R2 und verwenden Sie ausschließlich den Pin 3.3V.

Einschränkungen und Tipps:

Das Modul ist BLE und lässt sich nicht als klassisches Bluetooth-Audio- oder Seriell-Gerät koppeln. Die Reichweite von bis zu 60 m gilt im freien Feld, im Innenbereich sinkt sie durch Wände. Die nutzbare Übertragungsrate mit einem Smartphone liegt in der Größenordnung von 8 kB pro Sekunde, während die Verbindung zum Arduino bei 9600 Baud die Übertragung auf etwa 960 Byte pro Sekunde begrenzt.

Wenn Sie eine höhere Geschwindigkeit benötigen, stellen Sie das Modul auf 115200 Baud ein. Mit SoftwareSerial am Arduino Uno können hohe Geschwindigkeiten jedoch Daten verlieren. In diesem Fall verwenden Sie den Hardware-Serialport oder ein Board mit mehreren seriellen Ports.

Das Modul kann mit AT+ROLE1 auch als Master konfiguriert werden, um sich mit einem anderen BLE-Modul zu verbinden. Über AT-Befehle können Sie den Namen, das Passwort, die UUIDs und das Werbeintervall ändern, und bei batteriebetriebenen Geräten können Sie die Schlafmodi nutzen, um den Verbrauch zu senken.