ES-107Principiante

Auto Bluetooth con ESP32 (L298N)

Guida un'auto a due ruote via Bluetooth con il joystick del telefono; senza internet, su iPhone e Android. Questo progetto è la guida passo passo del modello Bluetooth Telecomando auto dell'app, montato con un ESP32, un L298N e due motori. Vai su La Mia Officina › Dispositivi › Aggiungi dispositivo › Bluetooth, scegli Telecomando auto e carica il codice da Ottieni il codice. Il pulsante Configura come pannello Bluetooth apre la procedura con questo modello.

0.0(0)
1 completato
Auto Bluetooth con ESP32 (L298N)
Che ne dici di guidare per casa, dal telefono, un'auto costruita da te? Il Bluetooth integrato dell'ESP32 si collega direttamente al telefono, senza internet, router o moduli in più. Nell'app aggiungi un dispositivo Bluetooth, scegli il modello Telecomando auto, carica il codice da Ottieni il codice e collegati alla tua scheda. Trascini il joystick e l'auto parte, lo lasci e si ferma; ci sono anche le frecce, un cursore della velocità e una vista a schermo intero. Il pulsante Configura come pannello Bluetooth di questa pagina ti porta dritto alla procedura. Impari: ricevere comandi via Bluetooth Low Energy, verso dei motori e velocità PWM con l'L298N, miscelazione del joystick e arresto di sicurezza.

Video

Schema circuito

Auto Bluetooth con ESP32 (L298N) - Schema circuito

Codice sorgente

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Araba                  │
5// └───────────────────────────┘
6// Telecomando auto
7// Scheda in Arduino IDE: ESP32 Dev Module
8// la libreria BLE arriva con il pacchetto schede ESP32, niente da installare in più
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Araba";  // la scheda si annuncia con questo nome e l’app la trova così nell’elenco
15
16// Pin: cambiali qui se hai collegato in modo diverso
17const int ENA = 14, IN1 = 27, IN2 = 26;  // Il motore A (ENA, IN1, IN2) è la ruota sinistra, il motore B (ENB, IN3, IN4) quella destra
18const int ENB = 32, IN3 = 25, IN4 = 33;
19const unsigned long COMMAND_TIMEOUT_MS = 500;  // Sicurezza: se per 500 ms non arriva nessun comando i motori si fermano (l’app lo ripete mentre guidi)
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── L’app invia righe "chiave=valore"; con "?" la scheda manda tutti i suoi valori ──
27char line[65];
28uint8_t lineLen = 0;
29unsigned long lastRxMs = 0;
30
31bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
32bool isOn(const char *v) { return v[0] == '1'; }
33
34void sendText(const char *key, const char *value) {
35  char out[72];
36  snprintf(out, sizeof(out), "%s=%s\n", key, value);
37  btWrite(out);
38}
39
40void sendInt(const char *key, long value) {
41  char text[12];
42  snprintf(text, sizeof(text), "%ld", value);
43  sendText(key, text);
44}
45
46void sendFloat(const char *key, float value) {
47  char text[16];
48  dtostrf(value, 1, 1, text);
49  sendText(key, text);
50}
51
52void handleLine(char *text) {
53  char *eq = strchr(text, '=');
54  if (eq == nullptr) {
55    if (text[strlen(text) - 1] == '?') {
56      btWrite("@v=1.0\n");  // la riga "@v" comunica all’app la versione del codice
57      sendAll();
58    }
59    return;
60  }
61  *eq = '\0';
62  onValue(text, eq + 1);
63}
64
65void feed(char c) {
66  lastRxMs = millis();
67  if (c == '\n' || c == '\r') {
68    if (lineLen == 0) return;
69    line[lineLen] = '\0';
70    lineLen = 0;
71    handleLine(line);
72  } else if (lineLen < sizeof(line) - 1) {
73    line[lineLen++] = c;
74  }
75}
76
77// ── Bluetooth (Nordic UART) ──
78#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
79#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
80#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
81
82BLECharacteristic *txChar = nullptr;
83volatile bool linked = false;
84volatile bool linkLost = false;
85// i byte in arrivo passano dal task Bluetooth a loop() tramite un piccolo buffer circolare
86const int RX_SIZE = 256;
87volatile uint8_t rxBuf[RX_SIZE];
88volatile int rxHead = 0, rxTail = 0;
89
90class ServerEvents : public BLEServerCallbacks {
91  void onConnect(BLEServer *server) override { linked = true; }
92  void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
93};
94
95class RxEvents : public BLECharacteristicCallbacks {
96  void onWrite(BLECharacteristic *c) override {
97    auto v = c->getValue();
98    for (size_t i = 0; i < v.length(); i++) {
99      int next = (rxHead + 1) % RX_SIZE;
100      if (next == rxTail) break;
101      rxBuf[rxHead] = (uint8_t)v[i];
102      rxHead = next;
103    }
104  }
105};
106
107// le righe partono in pacchetti da 20 byte (funziona con ogni telefono)
108void btWrite(const char *text) {
109  if (!linked || txChar == nullptr) return;
110  size_t n = strlen(text);
111  for (size_t i = 0; i < n; i += 20) {
112    size_t len = n - i < 20 ? n - i : 20;
113    txChar->setValue((uint8_t *)text + i, len);
114    txChar->notify();
115    delay(4);
116  }
117}
118
119void btBegin() {
120  BLEDevice::init(BLE_NAME);
121  BLEServer *server = BLEDevice::createServer();
122  server->setCallbacks(new ServerEvents());
123  BLEService *uart = server->createService(UART_SERVICE);
124  txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
125  txChar->addDescriptor(new BLE2902());
126  BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
127  rx->setCallbacks(new RxEvents());
128  uart->start();
129  BLEAdvertisementData adv;
130  adv.setFlags(0x06);
131  adv.setCompleteServices(BLEUUID(UART_SERVICE));
132  BLEAdvertisementData scan;
133  scan.setName(BLE_NAME);
134  BLEAdvertising *advertising = BLEDevice::getAdvertising();
135  advertising->setAdvertisementData(adv);
136  advertising->setScanResponseData(scan);
137  BLEDevice::startAdvertising();
138}
139
140void btPoll() {
141  while (rxTail != rxHead) {
142    char c = (char)rxBuf[rxTail];
143    rxTail = (rxTail + 1) % RX_SIZE;
144    feed(c);
145  }
146  if (linkLost) {
147    linkLost = false;
148    onLinkLost();
149    delay(100);
150    BLEDevice::startAdvertising();
151  }
152}
153
154// ── ESP32 ──
155int speedLimit = 80;  // limite di velocità dall’app (0–100 %)
156unsigned long lastCommandMs = 0;
157bool moving = false;
158
159// se l’auto va all’indietro, scambia i due fili di quel motore
160void motor(int en, int a, int b, int power) {
161  power = constrain(power, -100, 100);
162  digitalWrite(a, power > 0 ? HIGH : LOW);
163  digitalWrite(b, power < 0 ? HIGH : LOW);
164  analogWrite(en, abs(power) * speedLimit * 255L / 10000);
165}
166
167void drive(int left, int right) {
168  motor(ENA, IN1, IN2, left);
169  motor(ENB, IN3, IN4, right);
170  moving = left != 0 || right != 0;
171  lastCommandMs = millis();
172}
173
174void onValue(const char *key, const char *value) {
175  if (is(key, "joy")) {  // Joystick: y avanti/indietro, x sterza; diventa velocità della ruota sinistra e destra
176    const char *comma = strchr(value, ',');
177    int x = atoi(value), y = comma ? atoi(comma + 1) : 0;
178    drive(constrain(y + x, -100, 100), constrain(y - x, -100, 100));
179  } else if (is(key, "yon")) {
180    if (is(value, "ileri")) drive(100, 100);
181    else if (is(value, "geri")) drive(-100, -100);
182    else if (is(value, "sol")) drive(-70, 70);
183    else if (is(value, "sag")) drive(70, -70);
184    else drive(0, 0);
185  } else if (is(key, "hiz")) {
186    speedLimit = constrain(atoi(value), 0, 100);
187  }
188}
189
190void sendAll() {
191  sendInt("hiz", speedLimit);
192}
193
194void onLinkLost() {
195  drive(0, 0);  // Connessione persa: i motori si fermano
196}
197
198void setup() {
199  Serial.begin(115200);
200  int pins[] = { ENA, IN1, IN2, ENB, IN3, IN4 };
201  for (int pin : pins) pinMode(pin, OUTPUT);
202  drive(0, 0);
203  btBegin();
204  Serial.print(F("BlueGrays Bluetooth: "));
205  Serial.println(BLE_NAME);
206}
207
208void loop() {
209  btPoll();
210  if (moving && millis() - lastCommandMs > COMMAND_TIMEOUT_MS) drive(0, 0);
211}
212

FAQ

Funziona con l'iPhone? Che differenza c'è con l'HC-05?

Sì, funziona su iPhone e Android. I moduli Bluetooth classici come HC-05 e HC-06 non possono collegarsi a un iPhone, per questo il progetto usa il Bluetooth Low Energy integrato dell'ESP32 e non serve nessun modulo in più. Non provare ad associare la scheda nelle impostazioni Bluetooth del telefono; la connessione la crea solo l'app BlueGrays.

L'auto va all'indietro o una ruota gira al contrario.

Scambia i due fili del motore che gira al contrario sul morsetto a vite dell'L298N (motore sinistro OUT1/OUT2, motore destro OUT3/OUT4); lo dice anche il commento nel codice. Se premendo avanti l'auto gira su se stessa, è invertito un solo motore. Se girano entrambi nel verso giusto ma sinistra la porta a destra, scambia il motore sinistro con quello destro.

Come alimento l'ESP32? USB e batteria possono essere collegati insieme?

Le 2× 18650 (7,4 V) vanno all'ingresso 12V dell'L298N, e l'uscita 5V dell'L298N alimenta il pin VIN dell'ESP32; per questo il jumper del regolatore 5V sull'L298N deve restare inserito. Così l'auto va senza cavo. Se l'USB è collegato mentre carichi il codice, spegni la batteria o stacca il filo dei 5V, così le due alimentazioni non si scontrano. Il GND dell'L298N e quello dell'ESP32 devono essere sempre collegati.

Che portata ha? Cosa fa l’auto se la connessione cade?

Il Bluetooth Low Energy di solito arriva a 10-30 metri all'aperto; muri e persone in mezzo accorciano la distanza. Se la connessione cade, la scheda ferma subito i motori e torna a farsi trovare, così puoi ricollegarti dall'app. L'auto si ferma anche se la scheda non riceve comandi per 500 ms, quindi non scappa mai fuori portata.