Modulo Bluetooth JDY-18, BLE 4.2, interfaccia UART, portata 60 m

Questo tutorial utilizza la scheda Arduino Uno R3 per mettere in funzione il modulo JDY-18, un modulo Bluetooth Low Energy (BLE) 4.2 con interfaccia seriale UART. Il modulo non ha bisogno di un programma proprio, ma ha bisogno di un microcontrollore che gli parli sulla seriale, e Arduino Uno è sufficiente. Lo utilizzate in progetti che inviano dati al telefono o ricevono comandi da esso, come telecomandi, sensori senza fili o apparecchiature alimentate a batteria.

Come funziona:

Il modulo ha un proprio processore radio e appare nel telefono come dispositivo BLE. Dopo la connessione, un servizio con UUID FFE0 e una caratteristica FFE1 trasportano i dati in entrambe le direzioni. Tutto ciò che il telefono invia sulla caratteristica FFE1 esce dal pin TXD del modulo, mentre tutto ciò che entra nel pin RXD arriva al telefono. Questa si chiama trasmissione trasparente, perché il modulo non modifica il contenuto dei dati.

Di fabbrica, il modulo lavora come dispositivo slave (AT+HOSTEN0), con velocità seriale di 9600 baud (AT+BAUD4) e con il nome JDY-18. A 9600 baud un byte occupa circa 10 bit (start, 8 bit di dati, stop), quindi si possono trasferire circa 960 byte al secondo tra Arduino e il modulo. Sul lato radio, il modulo lavora a 2.4 GHz, con potenza di emissione massima di 0 dBm e un raggio di fino a 60 m in campo aperto.

Il modulo accetta solo una tensione bassa, quindi si alimenta dal pin 3.3V della scheda Uno. I segnali di Arduino Uno sono a 5 V, mentre l'ingresso RXD del modulo è a 3.3 V. Per questo motivo tra D3 e RXD si inserisce un partitore con due resistenze, R1 da 1 kΩ in serie e R2 da 2 kΩ verso GND. La tensione su RXD risulta dalla formula Vout = 5 V x 2 kΩ / (1 kΩ + 2 kΩ) = 3.33 V. In senso inverso, l'uscita TXD del modulo ha 3.3 V, un livello che Arduino Uno legge correttamente come logico 1, quindi TXD si collega direttamente a D2.

Il modulo consuma circa 4 mA quando è sveglio e trasmette, meno di 300 µA in sleep leggero e dell'ordine di 1.8 µA in sleep profondo. Il pin 3.3V della scheda Uno può erogare fino a 50 mA, quindi è sufficiente.

Collegamento:

Scollegate la scheda Uno dal USB prima di effettuare i collegamenti. Alimentate il modulo solo dal pin 3.3V, mai dal 5V, perché i 5 V possono distruggere il circuito. I cinque pin del modulo sono indicati sul retro del circuito, quindi verificate le diciture prima di collegare, perché l'ordine dei pin può differire da un lotto all'altro. Il pin STAT resta non collegato in questo tutorial. Usiamo SoftwareSerial sui pin D2 e D3, mentre la porta seriale hardware resta libera per il Monitor seriale.

Scheda e librerie:

Nell'Arduino IDE selezionate Strumenti > Scheda > Arduino AVR Boards > Arduino Uno. Il pacchetto Arduino AVR Boards è incluso nell'Arduino IDE, quindi non va installato separatamente dal Gestore schede. Il programma utilizza solo la libreria SoftwareSerial, che è inclusa nell'Arduino IDE, quindi non serve installare alcuna libreria dal Gestore librerie.

Il codice:

Il programma invia alcuni comandi AT all'avvio per verificare il collegamento con il modulo, poi collega il Monitor seriale al modulo in entrambe le direzioni, in modo che possiate inviare comandi AT oppure vedere i dati ricevuti dal telefono.

/*
  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());
  }
}

Come funziona il codice:

All'inizio, le costanti BT_RX_PIN e BT_TX_PIN fissano i pin D2 e D3, mentre l'oggetto bt di tipo SoftwareSerial crea una porta seriale software su questi pin. BT_RX_PIN è il pin su cui Arduino riceve i dati dal TXD del modulo, mentre BT_TX_PIN è il pin su cui Arduino invia dati al RXD del modulo tramite il partitore.

La funzione sendCommand() riceve un comando AT come testo, lo visualizza sul Monitor seriale con il prefisso "> " e svuota il buffer di ricezione, così da non mescolare le vecchie risposte con quella nuova. Poi invia il comando seguito da \r\n, perché il modulo richiede questa terminazione per ogni comando. Successivamente legge la risposta e la copia sul Monitor seriale finché il modulo resta in silenzio per 500 ms. Alla fine, se l'ultimo carattere non è stato un a capo, la funzione ne aggiunge uno, in modo che l'uscita successiva inizi su una riga separata.

In setup() si avvia il Monitor seriale a 9600 baud e la porta bt anch'essa a 9600 baud, la velocità di fabbrica del modulo. Dopo una pausa di 500 ms, durante la quale il modulo si avvia, il programma mostra il messaggio di avvio e invia quattro interrogazioni: AT+VERSION per la versione del firmware, AT+NAME per il nome trasmesso, AT+BAUD per il codice della velocità seriale e AT+LADDR per l'indirizzo MAC Bluetooth.

In loop() il programma funziona come un ponte seriale. Ogni byte ricevuto dal modulo viene scritto sul Monitor seriale, mentre ogni byte digitato nel Monitor seriale viene inviato al modulo. Così potete scrivere comandi AT a mano oppure vedere il testo inviato dal telefono.

Risultato:

Aprite il Monitor seriale a 9600 baud e scegliete come terminatore di riga "Sia NL che CR". Dopo alcuni secondi compaiono le risposte del modulo alle quattro interrogazioni, poi il messaggio che il ponte è pronto. I valori esatti possono variare, in particolare l'indirizzo MAC.

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.

Per verificare il collegamento con il telefono, aprite un'applicazione di terminale BLE, connettetevi al dispositivo JDY-18, attivate le notifiche sulla caratteristica FFE1 e inviate un testo. Il testo appare nel Monitor seriale. Ciò che scrivete nel Monitor seriale dopo la connessione arriva nell'applicazione.

Problemi frequenti:

Non compare nessuna risposta ai comandi AT. La causa più frequente è l'inversione dei pin TXD e RXD oppure il terminatore di riga sbagliato. Verificate che TXD vada a D2 e RXD a D3 tramite il partitore, e nel Monitor seriale scegliete "Sia NL che CR". Controllate anche la velocità di 9600 baud.

Le risposte compaiono con caratteri strani. La velocità seriale del modulo è stata cambiata oppure il Monitor seriale è impostato in modo errato. Impostate il Monitor seriale a 9600 baud e, se avete cambiato la velocità del modulo con AT+BAUD, usate lo stesso valore in bt.begin().

I comandi AT non vengono accettati. Finché un telefono è connesso, il modulo tratta i dati come dati trasparenti. Disconnettete il telefono oppure mantenete il pin PWRC a livello basso, se lo avete scollegato per una connessione propria.

Il modulo non compare nell'elenco del telefono. Verificate l'alimentazione dal pin 3.3V e la massa comune. Cercate il dispositivo con un'applicazione BLE, non nell'elenco Bluetooth classico del telefono, perché il JDY-18 utilizza solo BLE.

Il modulo si scalda oppure non risponde più dopo la connessione. È possibile che sia stato alimentato a 5 V oppure che abbia ricevuto un segnale a 5 V direttamente su RXD. Verificate il partitore R1 e R2 e usate solo il pin 3.3V.

Limitazioni e consigli:

Il modulo è BLE e non si accoppia come dispositivo audio o seriale Bluetooth classico. Il raggio di 60 m vale in campo aperto, mentre in interno diminuisce a causa dei muri. La velocità utile di trasferimento con un telefono è dell'ordine di 8 kB al secondo, mentre a 9600 baud il collegamento con Arduino limita il trasferimento a circa 960 byte al secondo.

Se avete bisogno di una velocità maggiore, impostate il modulo a 115200 baud, ma con SoftwareSerial su Arduino Uno le velocità elevate possono perdere dati. In questo caso usate la porta seriale hardware oppure una scheda con più porte seriali.

Il modulo può essere configurato anche come master, con AT+ROLE1, per connettersi a un altro modulo BLE. Dai comandi AT potete cambiare il nome, la password, gli UUID e l'intervallo di trasmissione, mentre per gli apparecchi alimentati a batteria potete usare le modalità di sleep per ridurre il consumo.