ES-108Iniciante

ESP32 Bluetooth LED e relé

Ligue e desligue um LED e um relé pelo celular via Bluetooth, sem internet nem Wi-Fi. Este projeto é o guia passo a passo do modelo Bluetooth LED e relé do app, montado com um ESP32 e um módulo relé de 5 V. Vá em Minha oficina › Dispositivos › Adicionar dispositivo › Bluetooth, escolha LED e relé e grave o código com Pegar o código. O botão Configurar como painel Bluetooth nesta página também abre o assistente com este modelo.

0.0(0)
ESP32 Bluetooth LED e relé
Toque num interruptor no celular e o relé na sua mesa faz clique: sem internet, sem roteador e sem servidor no meio. O ESP32 já tem Bluetooth, então o celular se conecta direto à placa e dois interruptores do painel comandam o LED e o relé. Quando o painel abre, a placa envia o estado real, então o que você vê na tela é o que está acontecendo na placa. No app, adicione um novo dispositivo, escolha Bluetooth e o modelo LED e relé, grave o código com Pegar o código e depois encontre sua placa na lista. O botão nesta página leva você à mesma configuração. Você aprende: conversar por Bluetooth Low Energy com linhas curtas de texto, um relé que liga com LOW e uma placa que informa o próprio estado ao painel. Nota sobre o relé: esta placa funciona com 3,3 V. Use um módulo de relé com optoacoplador, que possa ser acionado por um sinal de 3,3 V; módulos de 5 V sem optoacoplador podem não desligar com um sinal de 3,3 V.

Vídeo

Esquema do circuito

ESP32 Bluetooth LED e relé - Esquema do circuito

Código-fonte

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Lamba                  │
5// └───────────────────────────┘
6// LED e relé
7// Placa no Arduino IDE: ESP32 Dev Module
8// a biblioteca BLE vem com o pacote de placas ESP32, não precisa instalar nada a mais
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13
14const char BLE_NAME[] = "BG-Lamba";  // a placa se anuncia com este nome e o app a encontra assim na lista
15
16// Pinos: mude aqui se você ligou de outro jeito
17const int LED_PIN = 2;
18const int RELAY_PIN = 26;
19const bool RELAY_ACTIVE_LOW = true;  // a maioria dos módulos de relé liga com LOW
20
21void btWrite(const char *text);
22void onValue(const char *key, const char *value);
23void sendAll();
24void onLinkLost();
25
26// ── O app envia linhas "chave=valor"; ao receber "?" a placa manda todos os valores ──
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");  // a linha "@v" informa ao app a versão do código
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// os bytes recebidos passam da tarefa Bluetooth para o loop() por um pequeno buffer circular
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// as linhas saem em pacotes de 20 bytes (funciona com qualquer celular)
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 ──
155bool ledOn = false, relayOn = false;
156
157void setRelay(bool on) {
158  if (RELAY_ACTIVE_LOW) {
159    if (on) { pinMode(RELAY_PIN, OUTPUT); digitalWrite(RELAY_PIN, LOW); }
160    else { pinMode(RELAY_PIN, INPUT); }  // desligar libera o pino: um HIGH de 3,3 V não basta para desligar um módulo de 5 V
161  } else {
162    pinMode(RELAY_PIN, OUTPUT); digitalWrite(RELAY_PIN, on ? HIGH : LOW);
163  }
164}
165
166void apply() {
167  digitalWrite(LED_PIN, ledOn ? HIGH : LOW);
168  setRelay(relayOn);
169}
170
171void onValue(const char *key, const char *value) {
172  if (is(key, "led")) ledOn = isOn(value);
173  else if (is(key, "role")) relayOn = isOn(value);
174  apply();
175}
176
177void sendAll() {
178  sendInt("led", ledOn);
179  sendInt("role", relayOn);
180}
181
182void onLinkLost() {
183}
184
185void setup() {
186  Serial.begin(115200);
187  pinMode(LED_PIN, OUTPUT);
188  apply();
189  btBegin();
190  Serial.print(F("BlueGrays Bluetooth: "));
191  Serial.println(BLE_NAME);
192}
193
194void loop() {
195  btPoll();
196}
197

Perguntas frequentes

Funciona com iPhone?

Funciona. O Bluetooth Low Energy (BLE) embutido no ESP32 conversa com iPhone e com Android. O iPhone não se conecta a módulos de Bluetooth clássico como o HC-05 e o HC-06, e este projeto não precisa deles. Não tente parear a placa nas configurações de Bluetooth do celular; placas BLE podem não aparecer lá, isso é normal. Quem faz a conexão é o app BlueGrays.

Posso ligar uma lâmpada de verdade no relé?

O módulo relé consegue chavear 127/220 V, mas a rede elétrica pode matar. Neste projeto não há nada ligado aos bornes COM e NO; o relé mostra que funciona com o clique e o LED do módulo. Se quiser testar uma carga, comece com um circuito de baixa tensão, como uma pilha ou uma fonte de 12 V. Se for para a rede elétrica, faça isso com alguém experiente, não deixe fios ou parafusos expostos e não passe da corrente indicada no módulo.

Por que o LED azul da placa acende junto com o meu LED?

Em muitas placas ESP32 DevKit o LED azul da própria placa também está ligado ao GPIO2. O seu LED está no mesmo pino, então os dois piscam juntos; não é defeito. Até ajuda: se um fio estiver solto, o LED azul mostra que o comando chegou à placa. Se não quiser isso, passe o seu LED para outro pino (por exemplo GPIO4) e mude LED_PIN no código.

Precisa de internet ou Wi-Fi? Qual é o alcance?

Não precisa. O celular se conecta direto à placa por Bluetooth, sem roteador nem servidor. Dentro de casa o alcance costuma ficar em torno de 10 metros, e as paredes reduzem. A placa se conecta a um celular por vez; quando ele se desconecta, a placa volta a anunciar e outro celular pode se conectar. Para controlar de fora de casa, escolha um projeto que use o painel IoT por Wi-Fi do app.