ES-112Anfänger

ESP32 Bluetooth: Text auf dem LCD

Tipp einen Text ins Handy, und er erscheint per Bluetooth auf einem 16x2-LCD, ohne Internet oder WLAN. Dieses Projekt ist die Schritt-für-Schritt-Anleitung zur Bluetooth-Vorlage Text auf dem LCD in der App, gebaut mit ESP32 und I2C-LCD. Geh zu Werkstatt › Geräte › Gerät hinzufügen › Bluetooth, wähl Text auf dem LCD und lade den Code mit Code holen hoch. Die Taste Als Bluetooth-Panel einrichten auf dieser Seite öffnet den Assistenten mit dieser Vorlage.

0.0(0)
ESP32 Bluetooth: Text auf dem LCD
Tipp einen Text ins Handy, drück auf Senden, und er steht auf dem LCD vor dir, ganz ohne Internet. Der ESP32 hat Bluetooth an Bord, dein Handy verbindet sich direkt mit dem Board, und dank I2C-Modul braucht das Display nur vier Kabel. Auf ein 16x2-Display passen 32 Zeichen: 16 oben, der Rest unten. Der Code macht aus ä, ö, ü und Akzentbuchstaben einfache Buchstaben, unbekannte Zeichen werden zum Fragezeichen. Der Schalter Hintergrundlicht im Panel schaltet das Licht. Wähl in der App die Vorlage Text auf dem LCD, lade den Code hoch und finde dein Board in der Liste. Du lernst: Text per Bluetooth Low Energy senden, ein I2C-LCD ansteuern, Text auf Zeilen verteilen und Buchstaben per Tabelle umwandeln.

Video

Schaltplan

ESP32 Bluetooth: Text auf dem LCD - Schaltplan

Quellcode

C++ (Arduino IDE)
1// ┌───────────────────────────┐
2// │ BlueGrays · bluegrays.com │
3// │ Bluetooth · ESP32         │
4// │ BG-Ekran                  │
5// └───────────────────────────┘
6// Text auf dem LCD
7// Board in der Arduino IDE: ESP32 Dev Module
8// die BLE-Bibliothek kommt mit dem ESP32-Boardpaket, nichts extra zu installieren
9
10#include <BLEDevice.h>
11#include <BLEServer.h>
12#include <BLE2902.h>
13#include <Wire.h>
14#include <LiquidCrystal_I2C.h>  // Bibliotheksverwalter: 'LiquidCrystal I2C' (Frank de Brabander)
15
16const char BLE_NAME[] = "BG-Ekran";  // das Board sendet unter diesem Namen, die App findet es damit in der Liste
17
18// Pins: hier ändern, wenn du anders verkabelt hast
19const int SDA_PIN = 21, SCL_PIN = 22;
20const int LCD_COLS = 16, LCD_ROWS = 2;  // LCD-Größe: Spalten × Zeilen
21const uint8_t LCD_ADDRESS = 0x27;  // die meisten I2C-LCDs nutzen 0x27; bleibt der Bildschirm leer, probiere 0x3F
22
23void btWrite(const char *text);
24void onValue(const char *key, const char *value);
25void sendAll();
26void onLinkLost();
27
28// ── Die App sendet Zeilen im Format "Schlüssel=Wert"; bei "?" schickt das Board alle Werte ──
29char line[65];
30uint8_t lineLen = 0;
31unsigned long lastRxMs = 0;
32
33bool is(const char *a, const char *b) { return strcmp(a, b) == 0; }
34bool isOn(const char *v) { return v[0] == '1'; }
35
36void sendText(const char *key, const char *value) {
37  char out[72];
38  snprintf(out, sizeof(out), "%s=%s\n", key, value);
39  btWrite(out);
40}
41
42void sendInt(const char *key, long value) {
43  char text[12];
44  snprintf(text, sizeof(text), "%ld", value);
45  sendText(key, text);
46}
47
48void sendFloat(const char *key, float value) {
49  char text[16];
50  dtostrf(value, 1, 1, text);
51  sendText(key, text);
52}
53
54void handleLine(char *text) {
55  char *eq = strchr(text, '=');
56  if (eq == nullptr) {
57    if (text[strlen(text) - 1] == '?') {
58      btWrite("@v=1.0\n");  // die Zeile "@v" meldet der App die Codeversion
59      sendAll();
60    }
61    return;
62  }
63  *eq = '\0';
64  onValue(text, eq + 1);
65}
66
67void feed(char c) {
68  lastRxMs = millis();
69  if (c == '\n' || c == '\r') {
70    if (lineLen == 0) return;
71    line[lineLen] = '\0';
72    lineLen = 0;
73    handleLine(line);
74  } else if (lineLen < sizeof(line) - 1) {
75    line[lineLen++] = c;
76  }
77}
78
79// ── Bluetooth (Nordic UART) ──
80#define UART_SERVICE "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"
81#define UART_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
82#define UART_TX "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"
83
84BLECharacteristic *txChar = nullptr;
85volatile bool linked = false;
86volatile bool linkLost = false;
87// eingehende Bytes gelangen über einen kleinen Ringpuffer vom Bluetooth-Task in loop()
88const int RX_SIZE = 256;
89volatile uint8_t rxBuf[RX_SIZE];
90volatile int rxHead = 0, rxTail = 0;
91
92class ServerEvents : public BLEServerCallbacks {
93  void onConnect(BLEServer *server) override { linked = true; }
94  void onDisconnect(BLEServer *server) override { linked = false; linkLost = true; }
95};
96
97class RxEvents : public BLECharacteristicCallbacks {
98  void onWrite(BLECharacteristic *c) override {
99    auto v = c->getValue();
100    for (size_t i = 0; i < v.length(); i++) {
101      int next = (rxHead + 1) % RX_SIZE;
102      if (next == rxTail) break;
103      rxBuf[rxHead] = (uint8_t)v[i];
104      rxHead = next;
105    }
106  }
107};
108
109// Zeilen gehen in 20-Byte-Paketen raus (klappt mit jedem Handy)
110void btWrite(const char *text) {
111  if (!linked || txChar == nullptr) return;
112  size_t n = strlen(text);
113  for (size_t i = 0; i < n; i += 20) {
114    size_t len = n - i < 20 ? n - i : 20;
115    txChar->setValue((uint8_t *)text + i, len);
116    txChar->notify();
117    delay(4);
118  }
119}
120
121void btBegin() {
122  BLEDevice::init(BLE_NAME);
123  BLEServer *server = BLEDevice::createServer();
124  server->setCallbacks(new ServerEvents());
125  BLEService *uart = server->createService(UART_SERVICE);
126  txChar = uart->createCharacteristic(UART_TX, BLECharacteristic::PROPERTY_NOTIFY);
127  txChar->addDescriptor(new BLE2902());
128  BLECharacteristic *rx = uart->createCharacteristic(UART_RX, BLECharacteristic::PROPERTY_WRITE | BLECharacteristic::PROPERTY_WRITE_NR);
129  rx->setCallbacks(new RxEvents());
130  uart->start();
131  BLEAdvertisementData adv;
132  adv.setFlags(0x06);
133  adv.setCompleteServices(BLEUUID(UART_SERVICE));
134  BLEAdvertisementData scan;
135  scan.setName(BLE_NAME);
136  BLEAdvertising *advertising = BLEDevice::getAdvertising();
137  advertising->setAdvertisementData(adv);
138  advertising->setScanResponseData(scan);
139  BLEDevice::startAdvertising();
140}
141
142void btPoll() {
143  while (rxTail != rxHead) {
144    char c = (char)rxBuf[rxTail];
145    rxTail = (rxTail + 1) % RX_SIZE;
146    feed(c);
147  }
148  if (linkLost) {
149    linkLost = false;
150    onLinkLost();
151    delay(100);
152    BLEDevice::startAdvertising();
153  }
154}
155
156// ── ESP32 ──
157// siehst du nur Kästchen, dreh am blauen Poti auf der Rückseite (Kontrast)
158LiquidCrystal_I2C lcd(LCD_ADDRESS, LCD_COLS, LCD_ROWS);
159char rows[LCD_ROWS][LCD_COLS + 1];
160bool lightOn = true;
161
162// das LCD kennt nur einfache lateinische Buchstaben: Akzente fallen weg (é → e), andere werden zu ?
163const char FOLD[] = "AAAAAAACEEEEIIIIDNOOOOOxOUUUUYPsaaaaaaaceeeeiiiidnooooo/ouuuuypyAaAaAaCcCcCcCcDdDdEeEeEeEeEeGgGgGgGgHhHhIiIiIiIiIiJjJjKkkLlLlLlLlLlNnNnNnnNnOoOoOoOoRrRrRrSsSsSsSsTtTtTtUuUuUuUuUuUuWwYyYZzZzZzs";
164
165void toAscii(const char *in, char *out, size_t size) {
166  size_t n = 0;
167  const unsigned char *p = (const unsigned char *)in;
168  while (*p && n + 1 < size) {
169    unsigned char c = *p;
170    if (c < 0x80) { out[n++] = c >= 32 ? c : ' '; p++; continue; }
171    int len = c >= 0xF0 ? 4 : c >= 0xE0 ? 3 : c >= 0xC0 ? 2 : 1;
172    unsigned int code = (len == 2 && p[1]) ? ((c & 0x1F) << 6) | (p[1] & 0x3F) : 0;
173    out[n++] = (code >= 0xC0 && code <= 0x17F) ? FOLD[code - 0xC0] : '?';
174    for (int k = 0; k < len && *p; k++) p++;
175  }
176  out[n] = '\0';
177}
178
179void showRows() {
180  for (int r = 0; r < LCD_ROWS; r++) {
181    lcd.setCursor(0, r);
182    bool ended = false;
183    for (int c = 0; c < LCD_COLS; c++) {
184      if (rows[r][c] == '\0') ended = true;
185      lcd.write(ended ? ' ' : rows[r][c]);
186    }
187  }
188}
189
190// "yazi=" verteilt den Text über die Zeilen, "satir1=" … ersetzt eine einzelne Zeile
191void setText(const char *text) {
192  char flat[LCD_COLS * LCD_ROWS + 1];
193  toAscii(text, flat, sizeof(flat));
194  int len = strlen(flat);
195  for (int r = 0; r < LCD_ROWS; r++) {
196    int start = r * LCD_COLS;
197    int n = len > start ? min(LCD_COLS, len - start) : 0;
198    memcpy(rows[r], flat + start, n);
199    rows[r][n] = '\0';
200  }
201}
202
203void onValue(const char *key, const char *value) {
204  if (is(key, "yazi")) {
205    setText(value);
206    showRows();
207  } else if (strncmp(key, "satir", 5) == 0) {
208    int r = atoi(key + 5) - 1;
209    if (r < 0 || r >= LCD_ROWS) return;
210    toAscii(value, rows[r], LCD_COLS + 1);
211    showRows();
212  } else if (is(key, "isik")) {
213    lightOn = isOn(value);
214    if (lightOn) lcd.backlight(); else lcd.noBacklight();
215  }
216}
217
218void sendAll() {
219  char flat[LCD_COLS * LCD_ROWS + 1];
220  snprintf(flat, sizeof(flat), rows[1][0] ? "%-16s%s" : "%s", rows[0], rows[1]);
221  if (flat[0]) sendText("yazi", flat);
222  sendInt("isik", lightOn);
223}
224
225void onLinkLost() {
226}
227
228void setup() {
229  Serial.begin(115200);
230  Wire.begin(SDA_PIN, SCL_PIN);
231  lcd.init();
232  lcd.backlight();
233  setText("BlueGrays");
234  strncpy(rows[1], BLE_NAME, LCD_COLS);
235  rows[1][LCD_COLS] = '\0';
236  showRows();
237  btBegin();
238  Serial.print(F("BlueGrays Bluetooth: "));
239  Serial.println(BLE_NAME);
240}
241
242void loop() {
243  btPoll();
244}
245

FAQ

Klappt das mit dem iPhone?

Ja. Das eingebaute Bluetooth Low Energy (BLE) des ESP32 spricht mit iPhone und Android. Ein iPhone kann sich nicht mit klassischen Bluetooth-Modulen wie HC-05 und HC-06 verbinden, die brauchst du hier aber auch nicht. Versuch nicht, das Board in den Bluetooth-Einstellungen des Handys zu koppeln; BLE-Boards tauchen dort oft gar nicht auf, das ist normal. Die Verbindung stellt die BlueGrays-App her.

Zeigt das Display Umlaute und ß?

Nicht als Umlaut. Bevor der Text aufs Display kommt, vereinfacht der Code Buchstaben mit Umlaut oder Akzent: aus ä wird a, aus ö wird o, aus ü wird u und aus ß ein einzelnes s. Schreibst du Grüße, steht auf dem Display Gruse; gefällt dir das nicht, tipp gleich Gruesse. Zeichen, die nicht in der Umwandlungstabelle stehen (Emoji, kyrillische oder japanische Zeichen, Symbole wie ° und €), erscheinen als Fragezeichen. Die LCD-Vorschau im Panel zeigt vor dem Senden, wie der Text aussehen wird.

Kann ich ein 20x4-LCD nehmen?

Ja. Im Assistenten und im Code-Bildschirm gibt es die Auswahl LCD-Typ: 16x2 oder 20x4. Wählst du 20x4, erzeugt die App den Code für diese Größe. Die Verkabelung bleibt gleich: vier Kabel an denselben Pins. Ändere Spalten und Zeilen nicht von Hand in einem Code, den du für 16x2 geholt hast, denn auch andere Stellen im Code hängen von der Größe ab. Richtig ist: in der App den LCD-Typ umstellen und den Code neu holen. Diese Anleitung wurde mit einem 16x2-Display gebaut.

Wie viele Zeichen passen aufs Display, läuft langer Text durch?

Auf ein 16x2-Display passen 32 Zeichen: zwei Zeilen mit je 16. Das Textfeld im Panel nimmt auch nicht mehr an. Die ersten 16 Zeichen kommen in die obere Zeile, der Rest in die untere; der Code achtet nicht auf Wörter, deshalb kann ein Wort am Zeilenende getrennt werden. Der Text läuft nicht durch, er bleibt stehen. Um ein Wort in die untere Zeile zu schieben, setz Leerzeichen davor; die LCD-Vorschau zeigt die Aufteilung vor dem Senden. Ein neuer Text ersetzt den alten.