Progetti Arduino Bluetooth: 15 idee con HC-05, HM-10 ed ESP32
15 progetti Arduino Bluetooth: LED e relè dal telefono, auto Bluetooth, comando vocale, insegna LED, sensore BLE; confronto HC-05, HM-10, ESP32 e app.
I progetti Arduino Bluetooth trasformano il telefono in un telecomando che invia comandi senza fili ad Arduino, oppure ti fanno leggere sul telefono ciò che Arduino misura: accendere un LED o un relè, guidare un'auto robot, scrivere un messaggio su un'insegna LED scorrevole o vedere il valore di un sensore in tasca. Non servono internet né router: telefono e scheda parlano direttamente entro pochi metri. Per questo il Bluetooth è il primo metodo wireless che si impara, prima del Wi-Fi, e uno dei temi più scelti nei progetti scolastici.
Ma se scegli il modulo o l'app sbagliati, il progetto si blocca prima ancora di iniziare: un iPhone non vede mai un HC-05, alcune app parlano solo con moduli BLE e i nuovi ESP32 non hanno il Bluetooth classico. In questa guida confrontiamo prima HC-05, HC-06, HM-10 ed ESP32, poi app come App Inventor, Serial Bluetooth Terminal e Dabble, e quindi percorriamo 15 progetti dal più facile al più difficile. Ci sono anche due sketch pronti: controllo di LED, relè e luminosità con un HC-05 e controllo di un LED dal telefono con ESP32 BLE. Se usi il modulo per la prima volta, parti dall'articolo sul modulo Bluetooth HC-05.

Quale modulo Bluetooth? HC-05, HC-06, HM-10 ed ESP32
Tutti i moduli Bluetooth sembrano fare la stessa cosa, ma usano due tecnologie diverse. Il Bluetooth classico (SPP) si comporta come una porta seriale: ogni carattere inviato dal telefono viene letto da Arduino con Serial.read(), e il codice è semplicissimo. HC-05 e HC-06 appartengono a questo gruppo; funzionano senza problemi con Android, ma poiché Apple non apre questo profilo alle app sull'iPhone, su iOS sono invisibili. Il Bluetooth Low Energy (BLE) trasporta i dati tramite una piccola tabella di servizi e caratteristiche, consuma pochissimo e funziona sia con Android sia con iPhone. L'HM-10 è un modulo BLE che si collega ad Arduino come una porta seriale; l'ESP32 integra sia il Bluetooth classico sia il BLE. I chip più recenti come ESP32-S3 ed ESP32-C3 hanno solo il BLE.
| Modulo | Bluetooth | Ruolo | iPhone | Lato Arduino | Progetto ideale |
|---|---|---|---|---|---|
| HC-05 | 2.0 classico (SPP) | Master e slave | Non funziona | SoftwareSerial, 9600 baud | Telecomando Android, collegamento tra due Arduino |
| HC-06 | 2.0 classico (SPP) | Solo slave | Non funziona | SoftwareSerial, 9600 baud | Il telecomando Android più semplice |
| HM-10 | 4.0 BLE | Master e slave | Funziona | SoftwareSerial, 9600 baud | Progetti che devono funzionare con l'iPhone |
| ESP32 (classico) | Classico + BLE integrati | Entrambi | Funziona via BLE | BluetoothSerial o BLEDevice | Progetti senza modulo, sensore BLE, tastiera |
| ESP32-S3 / C3 | Solo BLE | Entrambi | Funziona | BLEDevice o NimBLE | Dispositivi BLE a basso consumo |
Quale app del telefono? Tabella di compatibilità tra app e moduli
Il lato telefono conta quanto quello Arduino. Per provare senza scrivere codice si usa un'app terminale, per un telecomando con pulsanti pannelli pronti come Dabble e per un design tutto tuo App Inventor. La regola è semplice: con i moduli classici (HC-05, HC-06) parlano solo le app Android, mentre con i moduli BLE (HM-10, ESP32 BLE) possono parlare sia app Android sia app per iPhone. La tabella mostra quale app funziona con quale modulo.
| App | Telefono | Moduli supportati | A cosa serve? |
|---|---|---|---|
| Serial Bluetooth Terminal | Android | HC-05, HC-06, HM-10, ESP32 | Inviare comandi e leggere i dati in arrivo; test rapidi con pulsanti macro |
| Dabble | Android e iOS | HC-05, HC-06 (Android), HM-10, ESP32 | Gamepad pronto, terminale, sensori del telefono; libreria Dabble su Arduino |
| App Inventor | Android (l'app la crei tu) | Moduli classici; HM-10 ed ESP32 con l'estensione BLE | Pulsanti, cursori e comandi vocali in un'app tutta tua |
| nRF Connect / LightBlue | Android e iOS | BLE (HM-10, ESP32) | Vedere i servizi BLE e scrivere valori nelle caratteristiche |
| Bluetooth Electronics | Android | HC-05, HC-06, HM-10 | Pannelli con pulsanti, cursori e grafici con il drag and drop |
15 progetti Arduino Bluetooth in una tabella
| # | Progetto | Scheda e modulo | Componenti extra | App del telefono | Livello |
|---|---|---|---|---|---|
| 1 | Accendere e spegnere un LED dal telefono | Uno + HC-05 | LED, 220 Ω | Serial Bluetooth Terminal | Facile |
| 2 | Controllo di una lampada con relè | Uno + HC-05 | Modulo relè | Serial Bluetooth Terminal, Dabble | Facile |
| 3 | Selettore di colore per LED RGB | Uno + HC-05 | LED RGB, 3 resistenze | App Inventor | Facile |
| 4 | Auto controllata via Bluetooth | Uno + HC-05 | L298N, telaio con 2 motori, batteria | Dabble Gamepad o app per auto RC | Medio |
| 5 | Controllo vocale | Uno + HC-05 | Relè o LED | App Inventor (riconoscimento vocale) | Medio |
| 6 | Insegna LED Bluetooth | Uno + HC-05 | Matrice MAX7219 8x32 | Serial Bluetooth Terminal | Medio |
| 7 | Servo e braccio robotico dal telefono | Uno + HC-05 | Servo SG90, 5 V esterni | Cursori di App Inventor | Medio |
| 8 | Dati del sensore sul telefono | Uno + HC-05 | DHT11 | Bluetooth Electronics, terminale | Facile |
| 9 | Serratura Bluetooth con password | Uno + HC-05 | Servo o serratura a solenoide | App Inventor | Medio |
| 10 | Bluetooth tra due Arduino | 2 × Uno + 2 × HC-05 | Pulsante, LED | Non serve | Medio |
| 11 | Gamepad con Dabble | Uno + HC-05 o HM-10 | Motori o LED | Dabble Gamepad | Facile |
| 12 | Controllo LED con ESP32 BLE | ESP32 | Nessuno (LED integrato) | nRF Connect, LightBlue | Medio |
| 13 | Sensore ESP32 BLE | ESP32 | DHT22 | nRF Connect, la tua app | Medio |
| 14 | Tastiera BLE e telecomando per presentazioni con ESP32 | ESP32 | 2–3 pulsanti | Non serve (il computer vede una tastiera) | Medio |
| 15 | Auto guidata con il controller di una console | ESP32 | Driver motori, telaio | Non serve (controller PS4 / Xbox) | Difficile |
Le prime due idee della lista esistono anche come progetti pronti nell'app BlueGrays: il progetto Accendere un LED dal telefono via Bluetooth realizza il progetto 1 e il progetto Auto Bluetooth con L298N il progetto 4, passo passo con schema e codice. Gli altri punti sono idee che puoi realizzare combinando i progetti con LED RGB, lampadina a 230 V con relè, servo e WS2812B dell'app con comandi Bluetooth; la tabella indica i componenti e il lato telefono di ciascuno.
Primi progetti con l'HC-05 (1–3): LED, relè e luminosità
I primi tre progetti usano lo stesso circuito e lo stesso codice. Non colleghiamo l'HC-05 ai pin seriali hardware 0 e 1 di Arduino, ma ai pin 10 e 11 con SoftwareSerial: così non devi staccare il modulo durante il caricamento e mantieni il monitor seriale per il debug. Il pin TX del modulo emette un segnale a 3,3 V che Arduino legge senza problemi. Nella direzione opposta, il segnale TX a 5 V di Arduino non deve arrivare direttamente al pin RX del modulo: un partitore di tensione con una resistenza da 1 kΩ e una da 2 kΩ abbassa i 5 V a circa 3,3 V.
| Collegamento | Arduino Uno | Nota |
|---|---|---|
| HC-05 VCC | 5V | La scheda del modulo ha un regolatore |
| HC-05 GND | GND | Massa comune |
| HC-05 TXD | D10 (RX di SoftwareSerial) | Collegamento diretto |
| HC-05 RXD | D11 (TX di SoftwareSerial) | Con partitore 1 kΩ (lato D11) + 2 kΩ (lato GND) |
| LED | D13 | Il LED della scheda è sullo stesso pin |
| IN del modulo relè | D7 | Il relè funziona a 5 V |
| LED PWM | D5 | Con resistenza da 220 Ω |
1// Arduino Uno + HC-05/HC-06: telefondan LED, röle ve PWM parlaklık kontrolü
2// Arduino Uno + HC-05/HC-06: control an LED, a relay and PWM brightness from your phone
3// Komutlar / Commands: L1, L0, R1, R0, P0..P255, ? (her komut satır sonuyla / each ends with a newline)
4#include <SoftwareSerial.h>
5
6#define BT_RX_PIN 10 // HC-05 TX buraya / HC-05 TX goes here
7#define BT_TX_PIN 11 // HC-05 RX'e gerilim bölücüyle / to HC-05 RX through a voltage divider
8#define LED_PIN 13
9#define RELAY_PIN 7
10#define PWM_PIN 5 // 220 ohm dirençli LED / LED with a 220 ohm resistor
11
12SoftwareSerial bt(BT_RX_PIN, BT_TX_PIN);
13char line[16];
14byte len = 0;
15int brightness = 0;
16
17void reportState() {
18 bt.print(F("LED=")); bt.print(digitalRead(LED_PIN));
19 bt.print(F(" ROLE=")); bt.print(digitalRead(RELAY_PIN));
20 bt.print(F(" PWM=")); bt.println(brightness);
21}
22
23void runCommand(const char* cmd) {
24 switch (cmd[0]) {
25 case 'L': digitalWrite(LED_PIN, cmd[1] == '1' ? HIGH : LOW); break;
26 case 'R': digitalWrite(RELAY_PIN, cmd[1] == '1' ? HIGH : LOW); break; // aktif LOW modülde tersle / invert for active-LOW modules
27 case 'P':
28 brightness = constrain(atoi(cmd + 1), 0, 255);
29 analogWrite(PWM_PIN, brightness);
30 break;
31 case '?': break;
32 default:
33 bt.println(F("Bilinmeyen komut / Unknown command"));
34 return;
35 }
36 reportState(); // her komuttan sonra durumu telefona yaz / send the state back after each command
37}
38
39void setup() {
40 pinMode(LED_PIN, OUTPUT);
41 pinMode(RELAY_PIN, OUTPUT);
42 pinMode(PWM_PIN, OUTPUT);
43 Serial.begin(9600);
44 bt.begin(9600); // HC-05 ve HC-06 varsayılan hızı / default HC-05 and HC-06 baud rate
45 Serial.println(F("Bluetooth hazir / Bluetooth ready"));
46}
47
48void loop() {
49 while (bt.available()) {
50 char c = bt.read();
51 if (c == '\r') continue;
52 if (c == '\n') { // satır bitti, komutu çalıştır / line complete, run it
53 line[len] = '\0';
54 if (len > 0) runCommand(line);
55 len = 0;
56 } else if (len < sizeof(line) - 1) {
57 line[len++] = toupper(c); // l1 ile L1 aynı / l1 equals L1
58 }
59 }
60}Il codice accumula i caratteri in arrivo in un buffer finché non arriva un fine riga (\n), poi esegue il comando. In questo modo i comandi di più caratteri come P128 vengono letti interi. In Serial Bluetooth Terminal imposta come fine riga "LF" o "CR+LF" nelle impostazioni; il codice ignora già il carattere \r. Dopo ogni comando Arduino rimanda al telefono lo stato attuale (per esempio LED=1 ROLE=0 PWM=128), così vedi che il comando ha funzionato davvero. La riga con toupper() accetta anche comandi scritti in minuscolo. Se il tuo modulo relè è attivo LOW, basta scambiare HIGH e LOW nelle righe di L e R. Puoi verificare perché bastano 220 Ω con il calcolatore della resistenza per LED.
Il progetto 3 estende la stessa logica a tre pin PWM: in App Inventor crei tre cursori per rosso, verde e blu, ognuno invia un testo come "R120" quando cambia e Arduino imposta quel colore con analogWrite(). Qui conta sapere se il LED RGB è ad anodo comune o a catodo comune; con anodo comune 255 significa spento e 0 massima luminosità (uso del LED RGB). Costruisci il circuito dei progetti BlueGrays Uso del LED RGB e Transizione morbida dei colori con LED RGB e aggiungi la parte di lettura dei comandi di questo codice per completare il progetto.
Progetti in movimento (4, 7): auto Bluetooth e braccio robotico
Il progetto 4 è il preferito tra i progetti Bluetooth: premendo le frecce sul telefono l'auto va avanti, indietro, a sinistra e a destra. La maggior parte delle app per auto RC invia una sola lettera per pulsante (F avanti, B indietro, L sinistra, R destra, S stop); Arduino imposta in base a quella lettera i quattro ingressi dell'L298N e regola la velocità con il PWM sui pin ENA ed ENB. Alimenta i motori con un pacco batterie da 7–12 V separato, non con i 5 V di Arduino, e unisci tutte le masse; altrimenti la tensione cala quando i motori partono e l'HC-05 perde la connessione. I dettagli del driver sono nell'articolo controllo dei motori DC con L298N. Nel progetto 7 ogni cursore di App Inventor invia l'angolo di un servo (come "A90" o "B45"); alimenta sempre due o più servo con una fonte esterna a 5 V.
Controllo con lo schermo del telefono e con la voce (5, 6, 8, 9)
Nel progetto 5 il riconoscimento vocale di App Inventor ascolta dal microfono del telefono e trasforma in testo ciò che dici; l'app invia quel testo, per esempio "accendi la luce", così com'è via Bluetooth. Su Arduino leggi la riga in una String e controlli il relè con semplici confronti come indexOf("accendi"). I caratteri accentati occupano più di un byte in UTF-8, quindi scrivi le parole di comando allo stesso modo su Arduino oppure fai convertire dall'app il testo in minuscolo senza accenti. Nel progetto 6 il messaggio che scrivi sul telefono scorre su una matrice LED 8x32 pilotata da chip MAX7219; la libreria MD_Parola gestisce lo scorrimento in una riga (matrice LED MAX7219). Tieni il messaggio in un array di char e limitane la lunghezza, perché i 2 KB di RAM dell'Uno si riempiono presto con testi lunghi.
Il progetto 8 funziona al contrario: ogni due secondi Arduino invia al telefono temperatura e umidità lette dal DHT11 come una riga del tipo "T:24.0,H:45". L'app Bluetooth Electronics può trasformare questa riga in un grafico o in un indicatore (sensore di temperatura e umidità DHT11). Nel progetto 9 l'app del telefono invia una password e, se è corretta, Arduino apre una serratura a solenoide tramite un servo o un relè. Il PIN di abbinamento Bluetooth da solo non garantisce sicurezza: non lasciare la password del comando fissa nel codice, aggiungi un'attesa dopo i tentativi sbagliati e costruisci la serratura in modo che si possa aprire anche meccanicamente in caso di blackout (serratura a solenoide).
Da modulo a modulo e pannelli pronti (10, 11)
Nel progetto 10 non c'è il telefono: uno dei due HC-05 viene impostato come master con i comandi AT e configurato per collegarsi automaticamente all'indirizzo dell'altro (con comandi come AT+ROLE=1 e AT+BIND). Una volta connessi, tutto ciò che un Arduino scrive sulla porta seriale viene letto dall'altro; puoi accendere con un pulsante un LED in un'altra stanza o mostrare senza fili il valore di un sensore. Poiché l'HC-06 può essere solo slave, questo progetto richiede almeno un HC-05. Il passaggio in modalità AT e l'elenco dei comandi sono nell'articolo sull'HC-05. Nel progetto 11 usi la schermata Gamepad pronta dell'app Dabble: installi la libreria Dabble su Arduino e leggi i pulsanti con funzioni come GamePad.isUpPressed(); sul telefono non devi progettare nulla. Con un HM-10 o un ESP32, Dabble funziona anche su iPhone.
Progetti Bluetooth con ESP32 (12–15): BLE, tastiera e controller da console
Sull'ESP32 il Bluetooth è integrato nella scheda, quindi non servono moduli né partitori. Il progetto 12 mostra come funziona il BLE: l'ESP32 si annuncia come "BlueGrays-LED" e contiene un servizio con una caratteristica scrivibile. Collegati alla scheda con nRF Connect o LightBlue e scrivi in quella caratteristica "1", "0" o "P128" come testo UTF-8: il LED si accende, si spegne o passa a metà luminosità. Poiché le stesse app funzionano anche su iPhone, questo progetto fa ciò che l'HC-05 non può fare.
1// ESP32 BLE: telefondan LED aç/kapa ve parlaklık (nRF Connect, LightBlue)
2// ESP32 BLE: switch an LED and set its brightness from your phone (nRF Connect, LightBlue)
3// Komutlar / Commands: 1, 0, P0..P255 (UTF-8 metin olarak yaz / write as UTF-8 text)
4#include <BLEDevice.h>
5#include <BLEServer.h>
6#include <BLEUtils.h>
7
8#define LED_PIN 2 // DevKit üzerindeki mavi LED / onboard blue LED on most DevKits
9#define SERVICE_UUID "4fafc201-1fb5-459e-8fcc-c5c9c331914b"
10#define CMD_UUID "beb5483e-36e1-4688-b7f5-ea07361b26a8"
11
12volatile bool connected = false;
13
14class ServerEvents : public BLEServerCallbacks {
15 void onConnect(BLEServer* server) override { connected = true; }
16 void onDisconnect(BLEServer* server) override {
17 connected = false;
18 BLEDevice::startAdvertising(); // bağlantı kopunca yeniden görünür ol / advertise again after disconnect
19 }
20};
21
22class CommandEvents : public BLECharacteristicCallbacks {
23 void onWrite(BLECharacteristic* ch) override {
24 String cmd = ch->getValue().c_str(); // 2.x ve 3.x çekirdekte çalışır / works on core 2.x and 3.x
25 cmd.trim();
26 if (cmd == "1") analogWrite(LED_PIN, 255);
27 else if (cmd == "0") analogWrite(LED_PIN, 0);
28 else if (cmd.startsWith("P")) analogWrite(LED_PIN, constrain(cmd.substring(1).toInt(), 0, 255));
29 Serial.println("Komut / Command: " + cmd);
30 }
31};
32
33void setup() {
34 Serial.begin(115200);
35 pinMode(LED_PIN, OUTPUT);
36
37 BLEDevice::init("BlueGrays-LED"); // telefonda görünen ad / name shown on the phone
38 BLEServer* server = BLEDevice::createServer();
39 server->setCallbacks(new ServerEvents());
40
41 BLEService* service = server->createService(SERVICE_UUID);
42 BLECharacteristic* cmdChar = service->createCharacteristic(
43 CMD_UUID, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
44 cmdChar->setCallbacks(new CommandEvents());
45 service->start();
46
47 BLEAdvertising* adv = BLEDevice::getAdvertising();
48 adv->addServiceUUID(SERVICE_UUID); // uygulamalar servisi taramada görsün / apps see the service while scanning
49 adv->setScanResponse(true);
50 BLEDevice::startAdvertising();
51 Serial.println("BLE yayinda: BlueGrays-LED / Advertising as BlueGrays-LED");
52}
53
54void loop() {
55 delay(1000); // tüm iş geri çağırmalarda / all work happens in the callbacks
56}La riga chiave del codice è la chiamata a startAdvertising() dentro onDisconnect: l'ESP32 smette di annunciarsi quando un telefono si connette e potrebbe non ricominciare da solo quando la connessione cade; senza questa riga non ritroveresti la scheda una seconda volta. Gli UUID del servizio e della caratteristica possono essere valori casuali qualsiasi a 128 bit; quando scrivi la tua app, basta usare gli stessi. La forma getValue().c_str() compila sia nelle versioni 2.x sia nelle 3.x del core Arduino ESP32. Nel progetto 13 alla stessa struttura si aggiunge una caratteristica leggibile con notifiche (notify); l'ESP32 invia al telefono ogni pochi secondi la temperatura letta da un DHT22. I dettagli sono nell'articolo ESP32 Bluetooth e BLE.
Nel progetto 14 l'ESP32 si presenta al computer o al telefono come una tastiera BLE. Con una libreria come ESP32-BLE-Keyboard, assegna le frecce destra e sinistra a due pulsanti e ottieni un telecomando che fa avanzare le slide delle presentazioni; assegna scorciatoie ad alcuni pulsanti e ottieni una piccola tastiera di macro. Sul computer non servono driver né app. Questa libreria è molto usata sul classico ESP32; scegli una versione compatibile con la tua versione del core. Nel progetto 15 la libreria Bluepad32 collega direttamente all'ESP32 un controller PS4, PS5 o Xbox; il risultato è un'auto robot di cui regoli con precisione la velocità con gli stick analogici (auto ESP32 con controller PS4).
Errori comuni nei progetti Arduino Bluetooth e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| L'iPhone non vede il modulo | HC-05 e HC-06 sono Bluetooth classico; iOS non lo apre alle app | Usa un HM-10 o l'ESP32 in BLE |
| Si abbina ma i comandi non arrivano | Velocità sbagliata o TX/RX invertiti | Usa 9600 baud; TX del modulo su D10, RX su D11 tramite il partitore |
| Caratteri strani sullo schermo | Arduino e modulo usano velocità diverse | Allinea bt.begin() alla velocità del modulo |
| Il codice non si carica | Il modulo è su D0 e D1 | Stacca il modulo durante il caricamento o spostalo su altri pin con SoftwareSerial |
| La connessione cade quando partono i motori | Calo di tensione | Alimenta i motori con una batteria separata, unisci le masse, aggiungi un condensatore |
| BluetoothSerial non compila sull'ESP32-S3 | Il chip non ha il Bluetooth classico | Usa il BLE o passa a una scheda ESP32 classica |
Da quale progetto Bluetooth iniziare?
- Hai un telefono Android e un HC-05: parti dai progetti 1 e 2 e invia i comandi a mano da Serial Bluetooth Terminal.
- Usi un iPhone: prendi un HM-10 o passa direttamente a un ESP32 e impara il BLE con il progetto 12.
- Vuoi il movimento: costruisci l'auto del progetto 4 provando prima i motori sollevati, poi montali sul telaio.
- Vuoi creare la tua app: passa ad App Inventor per i progetti 3 e 5; pulsanti e cursori inviano gli stessi comandi di testo.
- Vuoi controllare il computer: trasforma l'ESP32 in una tastiera BLE con il progetto 14.
Il bello dei progetti Bluetooth è che la stessa logica dei comandi funziona ovunque: il comando "L1" che oggi accende un LED domani gestisce un relè e dopodomani un'auto robot. Se scegli il modulo giusto per il tuo telefono e provi prima con un'app terminale, la maggior parte dei progetti funziona al primo tentativo. Nell'app BlueGrays trovi i progetti del LED via Bluetooth e dell'auto Bluetooth con L298N, oltre a progetti con LED RGB, relè, servo e WS2812B, ognuno con schema del circuito, elenco dei componenti e codice pronto, da combinare con i comandi Bluetooth.
Domande frequenti
Quali progetti Bluetooth si possono fare con Arduino?
I progetti Arduino Bluetooth più diffusi sono il controllo di LED e relè dal telefono, l'auto controllata via Bluetooth, la domotica a comando vocale, un'insegna LED su cui scrivi dal telefono, l'invio dei dati dei sensori al telefono e una serratura con password. Con un ESP32 puoi fare anche un sensore BLE, una tastiera BLE e il controllo con il controller di una console.
Che differenza c'è tra HC-05 e HC-06?
Entrambi sono moduli Bluetooth classici e comunicano con Arduino allo stesso modo tramite porta seriale. L'HC-05 può essere master o slave, quindi può collegare tra loro due Arduino; l'HC-06 è solo slave e aspetta che si connetta un dispositivo come un telefono.
L'HC-05 funziona con l'iPhone?
No. HC-05 e HC-06 usano il profilo di porta seriale del Bluetooth classico, che iOS non apre alle app. Per un progetto che deve funzionare con l'iPhone usa un modulo BLE come l'HM-10 o un ESP32 con BLE integrato.
Quale app usare per Arduino Bluetooth?
Per i test le scelte più pratiche sono Serial Bluetooth Terminal su Android e nRF Connect o LightBlue per i moduli BLE. Se vuoi un pannello di comando pronto usa Dabble, se vuoi progettare pulsanti e cursori tuoi usa App Inventor.
Perché serve una resistenza sul pin RX dell'HC-05?
L'HC-05 lavora con logica a 3,3 V, mentre il pin TX di Arduino Uno fornisce 5 V. Un partitore con una resistenza da 1 kΩ e una da 2 kΩ abbassa questo segnale a circa 3,3 V e protegge l'ingresso del modulo; dal TX del modulo verso Arduino non serve nessuna resistenza.
Qual è la portata del Bluetooth con Arduino?
HC-05, HC-06 e HM-10 arrivano a circa 10 metri in campo aperto; muri e corpo umano riducono questa distanza. Il Bluetooth integrato dell'ESP32 offre una portata simile; per distanze maggiori servono Wi-Fi, ESP-NOW o LoRa.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Controllare un LED dal telefono tramite Bluetooth
Una piccola prova per accendere e spegnere le luci della tua stanza dal telefono.

Auto controllata via Bluetooth con L298N
Trasforma il telefono in un telecomando e guida la tua auto robot. L'Arduino riceve tramite un modulo Bluetooth i comandi di un'app di controllo remoto sul telefono e fa girare le ruote con un driver…

Utilizzo dei LED RGB
Dentro un solo LED si nascondono tre colori: il LED RGB si accende rosso, poi verde, poi blu, ogni colore acceso per mezzo secondo e spento per mezzo secondo, e poi il giro ricomincia.

Accendere e spegnere una lampadina 220V con un pulsante
Vuoi accendere e spegnere una vera lampadina di casa con un piccolo pulsante? Ogni volta che lo premi, l'Arduino fa scattare un relè e la lampadina si accende; premendo di nuovo si spegne.

Utilizzo del servomotore
Il braccio di un piccolo servomotore ruota a turno in tre posizioni: tutto all'inizio, esattamente a metà e tutto alla fine, aspettando due secondi a ogni fermata.

Utilizzo della striscia LED WS2812B
Conosci una striscia LED intelligente in cui puoi colorare ogni singola luce per conto suo.

Controllo LED RGB ESP32
Generazione illimitata di colori con un singolo LED RGB invece di 3 LED separati. La transizione arcobaleno avviene impostando i valori R/G/B con analogWrite() come in Arduino. La teoria dei colori (come rosso+verde=giallo) viene vista in pratica.

Robot che evita gli ostacoli
Che ne dite di costruire un veicolo intelligente che trova la propria strada? L'Obstacle Avoiding Robot scruta costantemente l'ambiente circostante grazie al sensore a ultrasuoni posto davanti a lui.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

