La comunicazione Bluetooth
Lo standard Bluetooth è uno standard tecnico-industriale di trasmissione dati per reti personali senza fili WPAN (Wireless Personal Area Network). Fornisce un metodo standard, economico e sicuro per scambiare informazioni tra dispositivi diversi attraverso una frequenza radio sicura a corto raggio in grado di ricercare i dispositivi coperti dal segnale radio entro un raggio di qualche decina di metri mettendoli in comunicazione tra loro. Questi dispositivi possono essere ad esempio palmari, telefoni cellulari, personal computer, portatili, stampanti, fotocamere digitali, smartwatch, console per videogiochi, cuffie, purché provvisti delle specifiche hardware e software richieste dallo standard stesso. Il BT si è diffuso da tempo anche nel settore industriale (strumenti di misura, lettori ottici, ecc.) per il dialogo con i relativi datalogger.
Lo standard Bluetooth prevede varie versioni. Ogni versione ha delle caratteristiche diverse.
I moduli Bluetooth HC-05 e HC-06
Sono moduli molto semplici da usare, simili tra loro, con standard di comunicazione Bluetooth 2.0 + EDR che possono essere impiegati per comunicazioni seriali wireless punto-punto.
Sono dei moduli in quanto sono formati da una serie di componenti montati su delle schede siglate EGBT-045MS o EGBT-046S che sostanzialmente differiscono tra loro per il firmware caricato all’interno e di conseguenza per il funzionamento del loro pinout (Qui potrete scaricare il manuale).
Il modulo HC-06 ha un firmware “lite” con comandi AT limitati, è sempre in modalità AT quando non è collegato ad un altro dispositivo via Bluetooth e funziona solo come Slave (può solo connettersi ad apparati Master e non può instaurare nuove connessioni verso altri moduli Slave).
Il modulo HC-05 ha il firmware “completo” con molti comandi AT, per farlo entrare nella modalità AT occorre seguire una procedura (che verrà illustrata più avanti), può funzionare sia come Slave, allo stesso modo del modulo HC-06, che come Master (può instaurare quindi nuove connessioni verso altri apparati Slave).
Questi moduli si possono utilizzare, per esempio, per connettere dei Robot (slave) a dei telecomandi (master) quali PC o Smartphone o Schede pilota con moduli HC-05 Master.
Solitamente questi moduli si trovano già montati su una scheda adattatore JY-MCU o su una ZS-040, simili tra loro, che ne facilita l’utilizzo.
I moduli HC-06, dato che necessitano di meno componenti per essere utilizzati, hanno una versione “Lite” della scheda adattatore sulla quale mancano, tra l’altro, un pulsantino ed i pin EN e lo STATE, mentre i moduli HC-05 hanno la versione completa della scheda adattatore.
Significato dei pin:
A seconda della versione della scheda adattatore potremo trovare leggere differenze nelle piedinature, comunque vedremo il funzionamento di tutti i pin che potrete trovare:
– EN: questo pin, se messo LOW disattiva il modulo, se messo HIGH o non connesso il modulo funziona normalmente.
– VCC: è il pin dell’alimentazione che può andare dai 3,6 ai 6 V.
– GND: GND
– TXD: uscita seriale del modulo, da collegare all’RX del microcontrollore. Attenzione: questo segnale utilizza il livello logico 3,3 V.
– RXD: ingresso seriale del modulo, da collegare al TX del microcontrollore. Attenzione: questo segnale utilizza il livello logico 3,3 V.
– STATE : connesso al LED2 (Pin32) del modulo passa dallo stato LOW allo stato HIGH quando il modulo è connesso via Bluetooth, se connesso ad un pin Input di Arduino lo si può utilizzare per capire se il modulo è connesso via Bluetooth o no.
Inoltre a bordo degli adattatori c’è un led che lampeggia:
– Velocemente in maniera costante: Il modulo è acceso e pronto a connettersi.
– 2 lampeggi veloci ogni 5 secondi: Modulo connesso via Bluetooth.
– 1 lampeggio ogni 2 secondi: Modulo HT-05 in AT Mode.
I moduli HT-05 e HT-06 possono essere utilizzati in due modalità di funzionamento:
– Data Mode (Modalità Dati): In questa modalità, il modulo viene utilizzato per comunicare con altri dispositivi Bluetooth, il trasferimento dei dati avviene in questa modalità.
– AT Command Mode (Modalità Comando AT): In modalità di comando, possiamo comunicare con il modulo Bluetooth solo via seriale e tramite opportuni comandi AT possiamo configurare varie impostazioni e parametri del modulo. Ciò include conoscere le informazioni sul firmware, la modifica della velocità di trasmissione, la modifica del nome del modulo, ecc. Possiamo anche usarlo per impostare l’HC-05 come master o slave.
Uso dei moduli Bluetooth HC-05 e HC-06 con Arduino in modalità Slave
Quando si utilizzano nella modalità Slave in Data Mode non c’è differenza tra utilizzare l’HC-05 o l’HC-06, solitamente di default entrambi i moduli sono settati per lavorare in Slave, con velocità 9600 baud e la password per associare il modulo con un apparato è 0000 o 1234.
Lo schema di collegamento sarà il seguente:
Note sullo schema: i moduli Bluetooth montati su adattatori possono essere alimentati a 5V, però i segnali devono essere a 3,3V. Per quanto riguarda l’uscita TX del modulo che va verso RX di Arduino si può collegare direttamente senza problemi. Infatti i livelli logici 3,3 V vengono interpretati comunque correttamente HIGH da Arduino. Diverso è il discorso per l’ingresso RX del modulo, perché Arduino darà in uscita TX 5V. Per non rischiare di danneggiare il modulo si utilizza un partitore di tensione con due resistenze, R1 da 10kΩ e R2 da 20kΩ. Così facendo il livello di tensione che arriverà al Rx del Modulo Bluetooth sarà di circa 3,33 V, infatti:
Dato che 20kΩ non è un valore standard e che di solito nei kit di Arduino si trovano le resistenze da 10kΩ possiamo utilizzare 2 di queste in serie per farne una equivalente da 20kΩ, oppure due in parallelo per farne una da 5kΩ. In questo caso utilizzeremo come R1 quella da 5kΩ e come R2 una da 10kΩ, il risultato finale non cambierà.
Al posto del partitore di tensione si potrebbe utilizzare un convertitori di livelli logici, ma ci complicheremo un po’ lo schema.
Lo sketch da utilizzare per testare il funzionamento del modulo sarà il seguente:
#include <SoftwareSerial.h> #define Rxpin 2 // Tx per Bluetooth Rx per Arduino #define Txpin 3 // Rx per Bluetooth Tx per Arduino char BluetoothBuffer; char SerialBuffer; SoftwareSerial Bluetooth(Rxpin, Txpin); void setup() { Serial.begin(9600); Bluetooth.begin(9600); } void loop() { if (Bluetooth.available() > 0) { BluetoothBuffer = Bluetooth.read(); Serial.print(BluetoothBuffer); } if (Serial.available() > 0) { SerialBuffer = Serial.read(); Bluetooth.print(SerialBuffer); } }
Una volta caricato lo sketch su Arduino apriamo il monitor seriale dell’IDE con il pulsante 
Si aprirà la finestra Monitor Seriale ed impostare la velocità di comunicazione a “9600 Baud” e “Entrambi NL & CR)”
A questo punto ci serve un apparato da connettere al modulo bluetooth. Possiamo utilizzare uno Smartphone Android (quelli della Mela non riconoscono i moduli HC-05 e HC-06) e ci servirà una App che invi e ricevi i dati dal Modulo Bluetooth. Noi abbiamo la nostra “Makerslab BT Demo App” che fa al caso nostro.
Collegate il modulo Bluetooth allo Smartphone (per sapere come fare riferimento alla pagina dedicata all’App) e provate i vari pulsanti dell’App e vedrete delle lettere e dei numeri apparire sul Monitor seriale, viceversa se scrivete sul Monitor seriale ed inviate il dato quello che avrete scritto apparirà sull’apposito spazio dell’App.
Questo perché lo sketch caricato dell’esempio legge i dati in arrivo dal Computer sulla porta seriale di Arduino (tramite il cavo USB) e li ritrasmette sulla porta seriale Software collegata al modulo Bluetooth. Il modulo provvederà a convertire i dati ed inviarli via WiFi allo Smartphone.
Viceversa se il modulo riceve dei dati via WiFi inviati dallo Smartphone, li convertirà e li invierà alla seriale Software di Arduino, che a sua volta li trasmetterà al Computer tramite la porta USB.
Accendere e spegnere led, leggere sensori e molto altro con Bluetooth HC-05 e HC-06 con Arduino
Vediamo ora come si utilizzano nella pratica i moduli HC-05 e HC-06 per far fare qualcosa ad Arduino.
Il nuovo Schema da utilizzare è il seguente:
Questo schema ci permetterà di utilizzare tutte le funzione della Makerslab “BT Demo App” ed imparare così ad utilizzare questi moduli Bluetooth.
Lo sketch da utilizzare per testare il funzionamento del modulo sarà il seguente.
/****************************************************************** Librerie ******************************************************************/ #include <SoftwareSerial.h> /****************************************************************** Definizione dei pin e delle variabili ******************************************************************/ #define Rxpin 2 /* RX scheda Arduino da collegare al TX Bluetooth */ #define Txpin 3 /* TX scheda Arduino da collegare al RX Bluetooth */ #define Pulsante 4 /* Pin Pulsante */ #define OUT1 5 /* Pin Uscita OUT1 */ #define OUT2 6 /* Pin Uscita OUT2 */ #define OUT3 7 /* Pin Uscita OUT3 */ #define RGB_R 9 /* Pin LED RGB Rosso */ #define RGB_G 10 /* Pin LED RGB Giallo */ #define RGB_B 11 /* Pin LED RGB Verde */ #define Potenziometro A0 /* Pin Potenziometro */ String RGB_R_PWM; /* Valore PWM per il colore Rosso */ String RGB_G_PWM; /* Valore PWM per il colore Verde */ String RGB_B_PWM; /* Valore PWM per il colore Blu */ char coloreCorrente; int valorePotenziometro; int aa = 1; char bt_char; String stringa; SoftwareSerial Bluetooth(Rxpin, Txpin); void setup() { pinMode(OUT1, OUTPUT); pinMode(OUT2, OUTPUT); pinMode(OUT3, OUTPUT); pinMode(RGB_R, OUTPUT); pinMode(RGB_G, OUTPUT); pinMode(RGB_B, OUTPUT); pinMode(Pulsante, INPUT_PULLUP); Bluetooth.begin(9600); Serial.begin(9600); } void loop() { while (Bluetooth.available() > 0) { /* Questa parte di programma riceve i caratteri inviati al modulo Bluetooth e li compara con i caratteri R,G e B per estrarre il valore numerico per i relativi PWM e salva tutti i caratteri ricevuti in una stringa */ aa = 0; bt_char = Bluetooth.read(); stringa += bt_char; delay(3); if (bt_char == 'R') { coloreCorrente = 'R'; RGB_R_PWM = ""; } if (bt_char == 'G') { coloreCorrente = 'G'; RGB_G_PWM = ""; } if (bt_char == 'B') { coloreCorrente = 'B'; RGB_B_PWM = ""; } if (coloreCorrente == 'R' && bt_char != 'R') { RGB_R_PWM += bt_char; } if (coloreCorrente == 'G' && bt_char != 'G') { RGB_G_PWM += bt_char; } if (coloreCorrente == 'B' && bt_char != 'B') { RGB_B_PWM += bt_char; } } if (aa == 0) { /* si convertono i caratteri estratti per i valori RGB in numeri da inviare ai led PWM */ analogWrite(RGB_R, RGB_R_PWM.toInt()); analogWrite(RGB_G, RGB_G_PWM.toInt()); analogWrite(RGB_B, RGB_B_PWM.toInt()); /* in questa parte di programma si compara l'ultimo carattere ricevuto per eseguire azioni */ if (bt_char == 'A') { digitalWrite (OUT1, HIGH); } if (bt_char == 'a') { digitalWrite (OUT1, LOW); } if (bt_char == 'D') { digitalWrite (OUT2, HIGH); } if (bt_char == 'd') { digitalWrite (OUT2, LOW); } if (bt_char == 'C') { digitalWrite (OUT3, HIGH); } if (bt_char == 'c') { digitalWrite (OUT3, LOW); } /* Invio i dati raccolti alla Seriale Hardware */ Serial.println("----------"); Serial.print("R = "); Serial.println(RGB_R_PWM); Serial.print("G = "); Serial.println(RGB_G_PWM); Serial.print("B ="); Serial.println(RGB_B_PWM); Serial.print("Stringa ricevuta = "); Serial.println(stringa); Serial.print("Ultimo carattere ricevuto = "); Serial.println(bt_char); stringa = ""; /* Azzero la stringa */ bt_char = ""; /* Azzero l'ultimo carattere ricevuto */ aa = 1; coloreCorrente = 0; } /* Parte di programma per inviare dati all'applicazione */ if (digitalRead(Pulsante) == LOW) { valorePotenziometro = analogRead(Potenziometro); delay(300); // Ritardo utilizzato come antirimbalzo per il pulsante Bluetooth.println(valorePotenziometro); } }
La complessità della prima parte dello Sketch è dovuta al fatto che il bluetooth riceve dei caratteri e per poter gestire i PWM occorrono dei numeri, che per Arduino sono due cose differenti, infatti se riceviamo ad esempio 135 dal modulo Bluetooth non è un numero, ma sono 3 caratteri alfanumerici 1, 3 e 5.
Detto questo se non ci interessasse la parte PWM, ma solo ricevere dei caratteri per far eseguire ad Arduino delle operazioni, come per esempio accendere e spegnere un led o avviare un motore, lo Sketch sarebbe molto più semplice come il seguente:
/****************************************************************** Librerie ******************************************************************/ #include <SoftwareSerial.h> /****************************************************************** Definizione dei pin e delle variabili ******************************************************************/ #define Rxpin 2 /* RX scheda Arduino da collegare al TX Bluetooth */ #define Txpin 3 /* TX scheda Arduino da collegare al RX Bluetooth */ #define OUT1 5 /* Pin Uscita OUT1 */ #define OUT2 6 /* Pin Uscita OUT2 */ #define OUT3 7 /* Pin Uscita OUT3 */ int aa=1; char bt_char; SoftwareSerial Bluetooth(Rxpin, Txpin); void setup() { pinMode(OUT1, OUTPUT); pinMode(OUT2, OUTPUT); pinMode(OUT3, OUTPUT); Bluetooth.begin(9600); Serial.begin(9600); } void loop() { if (Bluetooth.available() > 0) { /* Salva l'ultimo carattere ricevuto dal modulo Bluetooth */ bt_char = Bluetooth.read(); delay(3); aa = 0; } if (aa == 0) { // Se ha ricevuto dati dal modulo lancia la verifica */ Serial.print("Ultitmo carattere ricevuto = "); Serial.println(bt_char); verificacarattere(); bt_char = ""; /* Azzero l'ultimo carattere ricevuto */ aa = 1; } } void verificacarattere() { /* verifica se i dati ricevuti corrispondono ad azioni da intraprendere */ switch (bt_char) { case 'A': digitalWrite (OUT1, HIGH); break; case 'a': digitalWrite (OUT1, LOW); break; case 'D': digitalWrite (OUT2, HIGH); break; case 'd': digitalWrite (OUT2, LOW); break; case 'C': digitalWrite (OUT3, HIGH); break; case 'c': digitalWrite (OUT3, LOW); break; } }
Uso dei moduli Bluetooth HC-05 e HC-06 con Arduino in modalità AT Mode
In questo caso c’è una sostanziale differenza tra i due moduli HC-05 e HC-06. Inoltre ci sono varie versioni di moduli anche con lo stesso nome, ce differenziano per la versione del Firmware.
Modalità AT Mode con HC-06
Partiamo prima con l’HC-06, questo modulo è sempre in modalità AT se non connesso via Bluetooth.
Lo schema è simile al primo visto:
Lo sketch da utilizzare per comunicare con il modulo in AT Mode è il seguente (lo stesso usato all’inizio):
#include <SoftwareSerial.h> #define Rxpin 2 // Tx per Bluetooth Rx per Arduino #define Txpin 3 // Rx per Bluetooth Tx per Arduino char BluetoothBuffer; char SerialBuffer; SoftwareSerial Bluetooth(Rxpin, Txpin); void setup() { Serial.begin(9600); Bluetooth.begin(9600); } void loop() { if (Bluetooth.available() > 0) { BluetoothBuffer = Bluetooth.read(); Serial.print(BluetoothBuffer); } if (Serial.available() > 0) { SerialBuffer = Serial.read(); Bluetooth.print(SerialBuffer); } }
Una volta caricato lo Sketch apriamo il Monitor seriale (come visto all’inizio della guida) ed inviamo la parola AT (attenzione: rispettare le maiuscole!) 
Se il modulo risponderà con un OK siamo nella modalità AT!
Provate a scrivere AT+VERSION
Ed il modulo ci risponderà con la versione del Firmware.
Con questa versione di modulo HC-06 sono disponibili solo alcuni dei comandi AT utilizzabili del modulo HC-05, in particolare quelli relativi al funziomanto come Slave, più avanti troverete l’elenco completo.
Modalità AT Mode con HC-05
Se avete a disposizione il modulo HC-05 con il pulsantino sulla scheda ed il pin EN lo schema sarà identico a quello utilizzato per l’HC-06.
Lo Sketch da utilizzare sarà uguale a quello utilizzato per l’HC-06 solo dovrete impostare la velocità delle due seriali a 38400 baud, quindi modificate solo questo pezzo di codice, così:
void setup() { Serial.begin(38400); Bluetooth.begin(38400); }
I passaggi da fare saranno:
Passo 1: Caricare lo Sketch sull’Arduino
Passo 2: Aprire il Monitor seriale ed impostare i baud a 38400
Passo 3: Scollegare il pin di Alimentazione del Modulo HC-05
Passo 4: Premere e mantenere premuto il pulsantino del modulo HC-05 e ricollegare l’alimentazione del modulo.
Passo 5: Il modulo si accenderà ed il LED del modulo lampeggerà lentamente, si può lasciare il pulsantino del modulo, siamo in AT mode.
Passo 6: Da terminale inviare AT , se il modulo risponde con OK siamo effettivamente in AT mode e possiamo configurare il modulo.
I comandi AT per il modulo HC-05 sono:
| Comando AT | Funzione del comando |
| AT | Testa la connessione all’interfaccia AT |
| AT + reset | Resetta il nostro componente |
| AT + version | Comunica la versione del firmware |
| AT + orgl | Riporta le impostazioni correnti alle predefinite |
| AT + addr | Il dispositivo ci comunica il proprio indirizzo |
| AT + name | Domandiamo o impostiamo il nome del dispositivo |
| AT + rname | Domandiamo il nome di un dispositivo bluetooth a cui siamo collegati (remoto) |
| AT + role | Domandiamo o impostiamo il ruolo del dispositivo (1=Master / 0=Slave) |
| AT + class | Domandiamo o impostiamo la classe del dispositivo ( Classe of Device CoD) |
| AT + iac | Domandiamo o impostiamo le richieste del codice di accesso |
| AT + inqm | Domandiamo o impostiamo le richieste della modalità di accesso |
| AT + pswd | Domandiamo la password o ne impostiamo l’associazione |
| AT + uart | Domandiamo i parametri UART o li reimpostiamo |
| AT + cmode | Domandiamo la modalità di connessione o la impostiamo |
| AT + bind | Domandiamo o impostiamo l’associazione all’indirizzo del bluetooth |
| AT + polar | Domandiamo o impostiamo la polarità di output del LED |
| AT + pio | Impostiamo o resettiamo un pin di Input/Output (I/O) utente |
| AT + mpio | Impostiamo o resettiamo più pin di I/O utente |
| AT + mpio? | Domandiamo l’I/O di un pin utente |
| AT + ipscan | Domandiamo o impostiamo i parametri di scansione |
| AT + sniff | Domandiamo o impostiamo i parametri di risparmio energetico SNIFF |
| AT + senm | Domandiamo o impostiamo i modi di sicurezza e crittografia |
| AT + rmsad | Elimina un dispositivo autenticato dalla lista |
| AT + fsad | Trova un dispositivo dalla lista dei dispositivi autenticati |
| AT + adcn | Domandiamo il numero totale dei dispositivi dalla lista dei dispositivi autenticati |
| AT + mrad | Domandiamo quale è il dispositivo autenticato utilizzato più di recente |
| AT + state | Domandiamo lo stato corrente del dispositivo |
| AT + init | Inizializziamo il profilo SPP (ricerca) |
| AT + inq | Domandiamo quale sia il dispositivo individuabile più vicino |
| AT + inqc | Cancelliamo la ricerca dei dispositivi individuabili |
| AT + pair | Associazione al dispositivo |
| AT + link | Connessione ad un dispositivo remoto |
| AT + disc | Disconnessione da un dispositivo remoto |
| AT + ensniff | Entriamo in modalità risparmio energetico |
| AT + exsniff | Usciamo dalla modalità di risparmio energetico |
Entrambi i moduli HC-05 e HC-06 durante l’AT mode possono restituirci dei messaggi di errore, ecco l’elenco:
| Codice errore | Significato |
| 0 | Comando errato o non valido |
| 1 | Valori risultanti di default |
| 2 | Scrittura della password errata |
| 3 | Il nome del dispositivo è troppo lungo ( maggiore di 32 caratteri ) |
| 4 | Nessun nome di dispositivo specificato ( 0 caratteri ) |
| 5 | L’indirizzo NAP del bluetooth è troppo lungo |
| 6 | L’indirizzo UAP del bluetooth è troppo lungo |
| 7 | L’indirizzo LAP del bluetooth è troppo lungo |
| 8 | Pin di Input/Output non specificato ( 0 caratteri ) |
| 9 | Pin I/O assegnato ad un numero di porta non valido |
| A | Classe del dispositivo non specificata ( 0 caratteri ) |
| B | Classe del dispositivo troppo lunga |
| C | Codice d’accesso non specificato ( 0 caratteri ) |
| D | Codice d’accesso troppo lungo |
| E | Codice d’accesso inserito non valido |
| F | Password di associazione non specificata ( 0 caratteri ) |
| 10 | Password di associazione troppo lunga ( maggiore di 16 caratteri ) |
| 11 | Ruolo non valido inserito |
| 12 | Baud rate non valido inserito |
| 13 | Bit d’arresto non valido inserito |
| 14 | Parity bit non valido inserito |
| 15 | Nessun dispositivo nella lista associati |
| 16 | Profilo di ricerca non inizializzato |
| 17 | Profilo di ricerca già inizializzato |
| 18 | Modalità di inchiesta non valida |
| 19 | Si è verificato un timeout nell’inchiesta |
| 1A | Indirizzo inserito non valido o non scritto |
| 1B | Modalità di sicurezza non valida inserita |
| 1C | Modalità di crittografia non valida inserita |