Guide · 11 min di lettura

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.

Modulo Bluetooth HC-05 usato nei progetti Arduino Bluetooth
HC-05: modulo Bluetooth classico (SPP); comunica con Arduino tramite porta seriale e funziona con i telefoni Android, non con l'iPhone.

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.

ModuloBluetoothRuoloiPhoneLato ArduinoProgetto ideale
HC-052.0 classico (SPP)Master e slaveNon funzionaSoftwareSerial, 9600 baudTelecomando Android, collegamento tra due Arduino
HC-062.0 classico (SPP)Solo slaveNon funzionaSoftwareSerial, 9600 baudIl telecomando Android più semplice
HM-104.0 BLEMaster e slaveFunzionaSoftwareSerial, 9600 baudProgetti che devono funzionare con l'iPhone
ESP32 (classico)Classico + BLE integratiEntrambiFunziona via BLEBluetoothSerial o BLEDeviceProgetti senza modulo, sensore BLE, tastiera
ESP32-S3 / C3Solo BLEEntrambiFunzionaBLEDevice o NimBLEDispositivi 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.

AppTelefonoModuli supportatiA cosa serve?
Serial Bluetooth TerminalAndroidHC-05, HC-06, HM-10, ESP32Inviare comandi e leggere i dati in arrivo; test rapidi con pulsanti macro
DabbleAndroid e iOSHC-05, HC-06 (Android), HM-10, ESP32Gamepad pronto, terminale, sensori del telefono; libreria Dabble su Arduino
App InventorAndroid (l'app la crei tu)Moduli classici; HM-10 ed ESP32 con l'estensione BLEPulsanti, cursori e comandi vocali in un'app tutta tua
nRF Connect / LightBlueAndroid e iOSBLE (HM-10, ESP32)Vedere i servizi BLE e scrivere valori nelle caratteristiche
Bluetooth ElectronicsAndroidHC-05, HC-06, HM-10Pannelli con pulsanti, cursori e grafici con il drag and drop
Inizia ogni progetto con Serial Bluetooth Terminal o nRF Connect. Se un comando scritto a mano funziona, il lato Arduino è corretto; creare poi un pannello Dabble o un'app App Inventor che invia gli stessi comandi richiede pochi minuti. Se vuoi creare la tua app, l'articolo App Inventor con Arduino Bluetooth la spiega passo passo.

15 progetti Arduino Bluetooth in una tabella

#ProgettoScheda e moduloComponenti extraApp del telefonoLivello
1Accendere e spegnere un LED dal telefonoUno + HC-05LED, 220 ΩSerial Bluetooth TerminalFacile
2Controllo di una lampada con relèUno + HC-05Modulo relèSerial Bluetooth Terminal, DabbleFacile
3Selettore di colore per LED RGBUno + HC-05LED RGB, 3 resistenzeApp InventorFacile
4Auto controllata via BluetoothUno + HC-05L298N, telaio con 2 motori, batteriaDabble Gamepad o app per auto RCMedio
5Controllo vocaleUno + HC-05Relè o LEDApp Inventor (riconoscimento vocale)Medio
6Insegna LED BluetoothUno + HC-05Matrice MAX7219 8x32Serial Bluetooth TerminalMedio
7Servo e braccio robotico dal telefonoUno + HC-05Servo SG90, 5 V esterniCursori di App InventorMedio
8Dati del sensore sul telefonoUno + HC-05DHT11Bluetooth Electronics, terminaleFacile
9Serratura Bluetooth con passwordUno + HC-05Servo o serratura a solenoideApp InventorMedio
10Bluetooth tra due Arduino2 × Uno + 2 × HC-05Pulsante, LEDNon serveMedio
11Gamepad con DabbleUno + HC-05 o HM-10Motori o LEDDabble GamepadFacile
12Controllo LED con ESP32 BLEESP32Nessuno (LED integrato)nRF Connect, LightBlueMedio
13Sensore ESP32 BLEESP32DHT22nRF Connect, la tua appMedio
14Tastiera BLE e telecomando per presentazioni con ESP32ESP322–3 pulsantiNon serve (il computer vede una tastiera)Medio
15Auto guidata con il controller di una consoleESP32Driver motori, telaioNon 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.

CollegamentoArduino UnoNota
HC-05 VCC5VLa scheda del modulo ha un regolatore
HC-05 GNDGNDMassa comune
HC-05 TXDD10 (RX di SoftwareSerial)Collegamento diretto
HC-05 RXDD11 (TX di SoftwareSerial)Con partitore 1 kΩ (lato D11) + 2 kΩ (lato GND)
LEDD13Il LED della scheda è sullo stesso pin
IN del modulo relèD7Il relè funziona a 5 V
LED PWMD5Con resistenza da 220 Ω
C++ (Arduino IDE)
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.

Durante l'abbinamento con il telefono, il PIN dell'HC-05 è di solito 1234 o 0000. Se la spia del modulo lampeggia velocemente è in attesa di abbinamento; un doppio lampeggio ogni due secondi indica che è connesso. Se l'abbinamento riesce ma i comandi non arrivano, il primo sospettato è la velocità: in modalità dati l'HC-05 usa per impostazione predefinita 9600 baud, mentre 38400 vale solo in modalità comandi AT.

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.

Aggiungi un timer di sicurezza perché l'auto non scappi mai: se sono passati 500 ms dall'ultimo comando, ferma i motori. Quando il telefono esce dalla portata o la connessione cade, l'auto si ferma sul posto invece di finire contro il muro.

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.

C++ (Arduino IDE)
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

SintomoCausa probabileSoluzione
L'iPhone non vede il moduloHC-05 e HC-06 sono Bluetooth classico; iOS non lo apre alle appUsa un HM-10 o l'ESP32 in BLE
Si abbina ma i comandi non arrivanoVelocità sbagliata o TX/RX invertitiUsa 9600 baud; TX del modulo su D10, RX su D11 tramite il partitore
Caratteri strani sullo schermoArduino e modulo usano velocità diverseAllinea bt.begin() alla velocità del modulo
Il codice non si caricaIl modulo è su D0 e D1Stacca il modulo durante il caricamento o spostalo su altri pin con SoftwareSerial
La connessione cade quando partono i motoriCalo di tensioneAlimenta i motori con una batteria separata, unisci le masse, aggiungi un condensatore
BluetoothSerial non compila sull'ESP32-S3Il chip non ha il Bluetooth classicoUsa il BLE o passa a una scheda ESP32 classica
Puoi calcolare il partitore per il pin RX dell'HC-05 con lo strumento partitore di tensione: 1 kΩ e 2 kΩ danno 5 V × 2 / 3 ≈ 3,3 V. Se non hai una resistenza da 2 kΩ, una da 1 kΩ più altre due da 1 kΩ in serie danno lo stesso risultato.

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.

Vedi tutti i progetti
Controllare un LED dal telefono tramite Bluetooth
AR-34Principiante
Premium

Controllare un LED dal telefono tramite Bluetooth

Una piccola prova per accendere e spegnere le luci della tua stanza dal telefono.

4.8(69)
91
Auto controllata via Bluetooth con L298N
AR-80Avanzato
Premium

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…

5.0(39)
66
Utilizzo dei LED RGB
AR-39Principiante
Premium

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.

4.9(73)
100
Accendere e spegnere una lampadina 220V con un pulsante
AR-20Avanzato
Premium

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.

4.5(33)
44
Utilizzo del servomotore
AR-35Principiante
Premium

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.

4.7(48)
67
Utilizzo della striscia LED WS2812B
AR-69Intermedio
Premium

Utilizzo della striscia LED WS2812B

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

4.8(54)
70
Controllo LED RGB ESP32
ES-9Principiante

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.

4.6(29)
52
Robot che evita gli ostacoli
AR-81Avanzato
Premium

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.

5.0(38)
49