ESP32 Bluetooth Monitor Beispiel - Echtzeit Serial Monitor Interface Tutorial
Überblick
Das Bluetooth Monitor Beispiel bietet eine kabellose Serial Monitor-Schnittstelle, die über die DIYables Bluetooth STEM App zugänglich ist. Entwickelt für ESP32-Boards mit Unterstützung für sowohl BLE (Bluetooth Low Energy) als auch Classic Bluetooth-Verbindungen. Streamen Sie Echtzeit-Statusmeldungen an die App, empfangen und verarbeiten Sie Textbefehle, zeigen Sie Systeminformationen an und debuggen Sie Ihre Projekte kabellos — perfekt für kabelloses Monitoring, Remote-Debugging und Systemstatus-Anzeigen.
Dieses Beispiel unterstützt zwei Bluetooth-Modi:
- ESP32 BLE (Bluetooth Low Energy): Funktioniert sowohl auf Android als auch iOS
- ESP32 Classic Bluetooth: Funktioniert nur auf Android. iOS unterstützt kein Classic Bluetooth. Verwenden Sie BLE, wenn Sie iOS-Unterstützung benötigen.
Funktionen
- Echtzeit-Streaming: Senden Sie kontinuierliche Statusmeldungen an die App-Anzeige
- Befehlsverarbeitung: Empfangen und verarbeiten Sie Textbefehle von der App
- Systemüberwachung: Zeigen Sie Betriebszeit, freien Heap-Speicher, CPU-Informationen und mehr an
- LED-Steuerung: Integrierte LED EIN/AUS-Befehle für schnelle Tests
- Periodische Updates: Automatische Heartbeat- und Statusmeldungen in konfigurierbaren Intervallen
- BLE & Classic Bluetooth: Wählen Sie den Bluetooth-Modus, der zu Ihrem Projekt passt
- Plattformübergreifend: BLE-Modus funktioniert sowohl auf Android als auch iOS; Classic Bluetooth funktioniert auf Android
- Niedrigstromverbrauch: BLE-Modus verbraucht weniger Strom als Classic Bluetooth
Benötigte Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 Starter-Kit (ESP32 enthalten) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
ESP32 Code
Schnelle Schritte
Folgen Sie diesen Anweisungen Schritt für Schritt:
- Wenn Sie zum ersten Mal den ESP32 verwenden, lesen Sie das Tutorial über die Einrichtung der Umgebung für ESP32 in der Arduino IDE.
- Verbinden Sie das ESP32-Board mit Ihrem Computer über ein USB-Kabel.
- Starten Sie die Arduino IDE auf Ihrem Computer.
- Wählen Sie das entsprechende ESP32-Board und den COM-Port aus.
- Navigieren Sie zum Libraries-Symbol in der linken Leiste der Arduino IDE.
- Suchen Sie nach "DIYables Bluetooth" und finden Sie die DIYables Bluetooth-Bibliothek von DIYables
- Klicken Sie auf den Install-Button, um die Bibliothek zu installieren.
- Sie werden gefragt, ob Sie weitere Bibliotheksabhängigkeiten installieren möchten
- Klicken Sie auf den Install All-Button, um alle Bibliotheksabhängigkeiten zu installieren.
Wählen Sie einen der beiden Bluetooth-Modi unten je nach Ihren Anforderungen:
ESP32 Classic Bluetooth Code (funktioniert nur mit der App auf Android)
Hinweis: Classic Bluetooth wird NICHT auf iOS unterstützt. Wenn Sie iOS-Unterstützung benötigen, verwenden Sie den BLE-Code unten.
- Gehen Sie in der Arduino IDE zu File Examples DIYables Bluetooth Esp32Bluetooth_Monitor Beispiel oder kopieren Sie den obigen Code und fügen Sie ihn in den Editor der Arduino IDE ein
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Monitor Example
* Works with DIYables Bluetooth STEM app on Android
* Note: Classic Bluetooth is NOT supported on iOS. Use BLE examples for iOS support.
*
* This example demonstrates the Bluetooth Monitor feature:
* - Send real-time status messages to the mobile app
* - Display system information and sensor readings
* - Receive and process commands from the app
* - Perfect for debugging and system monitoring
*
* Compatible Boards:
* - ESP32 (all variants with Classic Bluetooth)
* - ESP32-WROOM-32
* - ESP32-DevKitC
* - ESP32-WROVER
*
* Note: Select "Huge APP (3MB No OTA/1MB SPIFFS)" partition scheme
* in Arduino IDE: Tools > Partition Scheme
*
* Setup:
* 1. Upload the sketch to your ESP32
* 2. Open Serial Monitor (115200 baud) to see connection status
* 3. Use DIYables Bluetooth App to connect and view monitor output
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothMonitor.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Monitor");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Monitor app instance
DIYables_BluetoothMonitor bluetoothMonitor;
// Variables for demo
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 3000; // Send update every 3 seconds
int messageCount = 0;
bool ledState = false;
// ESP32 built-in LED (may vary by board)
const int LED_PIN = 2;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Monitor Example");
// Initialize LED
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add monitor app to server
bluetoothServer.addApp(&bluetoothMonitor);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothMonitor.send("=== ESP32 Monitor Connected ===");
bluetoothMonitor.send("System Ready");
bluetoothMonitor.send("Type HELP for available commands");
bluetoothMonitor.send("");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up message handler for incoming commands
bluetoothMonitor.onMonitorMessage([](const String& message) {
Serial.print("Received command: ");
Serial.println(message);
handleCommand(message);
});
Serial.println("Waiting for Bluetooth connection...");
}
void handleCommand(const String& cmd) {
if (cmd == "HELP") {
bluetoothMonitor.send("Available Commands:");
bluetoothMonitor.send(" LED_ON - Turn LED on");
bluetoothMonitor.send(" LED_OFF - Turn LED off");
bluetoothMonitor.send(" STATUS - Show system status");
bluetoothMonitor.send(" HEAP - Show memory info");
bluetoothMonitor.send(" CLEAR - Clear monitor (if supported)");
bluetoothMonitor.send(" HELP - Show this help");
}
else if (cmd == "LED_ON") {
digitalWrite(LED_PIN, HIGH);
ledState = true;
bluetoothMonitor.send("✓ LED turned ON");
}
else if (cmd == "LED_OFF") {
digitalWrite(LED_PIN, LOW);
ledState = false;
bluetoothMonitor.send("✓ LED turned OFF");
}
else if (cmd == "STATUS") {
showStatus();
}
else if (cmd == "HEAP") {
bluetoothMonitor.send("=== Memory Info ===");
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("Min Free Heap: " + String(ESP.getMinFreeHeap()) + " bytes");
bluetoothMonitor.send("Heap Size: " + String(ESP.getHeapSize()) + " bytes");
bluetoothMonitor.send("===================");
}
else if (cmd == "CLEAR") {
bluetoothMonitor.send("");
}
else {
bluetoothMonitor.send("✗ Unknown command: " + cmd);
bluetoothMonitor.send("Type HELP for available commands");
}
}
void showStatus() {
bluetoothMonitor.send("=== System Status ===");
// LED Status
bluetoothMonitor.send("LED State: " + String(ledState ? "ON" : "OFF"));
// Uptime
unsigned long uptime = millis() / 1000;
bluetoothMonitor.send("Uptime: " + String(uptime / 3600) + "h " + String((uptime % 3600) / 60) + "m " + String(uptime % 60) + "s");
// ESP32-specific info
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("CPU Freq: " + String(ESP.getCpuFreqMHz()) + " MHz");
bluetoothMonitor.send("Chip Model: " + String(ESP.getChipModel()));
// Messages sent
bluetoothMonitor.send("Messages Sent: " + String(messageCount));
bluetoothMonitor.send("====================");
}
void sendPeriodicUpdate() {
messageCount++;
// Example of different message types
if (messageCount % 3 == 0) {
bluetoothMonitor.send("[INFO] Heartbeat #" + String(messageCount));
}
else if (messageCount % 5 == 0) {
bluetoothMonitor.send("[HEAP] Free: " + String(ESP.getFreeHeap()) + " bytes");
}
else {
bluetoothMonitor.send("[TIME] Uptime: " + String(millis() / 1000) + "s");
}
Serial.print("Sent update #");
Serial.println(messageCount);
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Send periodic updates (only when connected)
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
sendPeriodicUpdate();
}
delay(10);
}
- Klicken Sie auf den Upload-Button in der Arduino IDE, um den Code auf den ESP32 hochzuladen
- Öffnen Sie den Serial Monitor
- Überprüfen Sie das Ergebnis im Serial Monitor. Es sieht folgendermaßen aus:
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
DIYables Bluetooth - ESP32 Monitor Example
Waiting for Bluetooth connection...
ESP32 BLE Code (funktioniert mit der App auf Android und iOS)
- Gehen Sie in der Arduino IDE zu File Examples DIYables Bluetooth Esp32BLE_Monitor Beispiel oder kopieren Sie den obigen Code und fügen Sie ihn in den Editor der Arduino IDE ein
/*
* DIYables Bluetooth Library - ESP32 BLE Monitor Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Monitor feature:
* - Send real-time status messages to the mobile app
* - Display system information and sensor readings
* - Receive and process commands from the app
* - Perfect for debugging and system monitoring
*
* Compatible Boards:
* - ESP32-WROOM-32
* - ESP32-DevKitC
* - ESP32-WROVER
* - ESP32-S3
* - ESP32-C3
* - Any ESP32 board supporting BLE
*
* Note: Select "Huge APP (3MB No OTA/1MB SPIFFS)" partition scheme
* in Arduino IDE: Tools > Partition Scheme
*
* Setup:
* 1. Upload the sketch to your ESP32
* 2. Open Serial Monitor (115200 baud) to see connection status
* 3. Use DIYables Bluetooth App to connect and view monitor output
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothMonitor.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Monitor";
const char* SERVICE_UUID = "19B10000-E8F2-537E-4F6C-D104768A1214";
const char* TX_UUID = "19B10001-E8F2-537E-4F6C-D104768A1214";
const char* RX_UUID = "19B10002-E8F2-537E-4F6C-D104768A1214";
// Create Bluetooth instances
DIYables_Esp32BLE bluetooth(DEVICE_NAME, SERVICE_UUID, TX_UUID, RX_UUID);
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Monitor app instance
DIYables_BluetoothMonitor bluetoothMonitor;
// Variables for demo
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 3000;
int messageCount = 0;
bool ledState = false;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Monitor Example");
// Initialize built-in LED
pinMode(2, OUTPUT); // ESP32 built-in LED is usually on GPIO 2
digitalWrite(2, LOW);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add monitor app to server
bluetoothServer.addApp(&bluetoothMonitor);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothMonitor.send("=== ESP32 BLE Monitor Connected ===");
bluetoothMonitor.send("System Ready");
bluetoothMonitor.send("Type HELP for available commands");
bluetoothMonitor.send("");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up message handler for incoming commands
bluetoothMonitor.onMonitorMessage([](const String& message) {
Serial.print("Received command: ");
Serial.println(message);
handleCommand(message);
});
Serial.println("Waiting for Bluetooth connection...");
}
void handleCommand(const String& cmd) {
if (cmd == "HELP") {
bluetoothMonitor.send("Available Commands:");
bluetoothMonitor.send(" LED_ON - Turn LED on");
bluetoothMonitor.send(" LED_OFF - Turn LED off");
bluetoothMonitor.send(" STATUS - Show system status");
bluetoothMonitor.send(" HEAP - Show free heap memory");
bluetoothMonitor.send(" HELP - Show this help");
}
else if (cmd == "LED_ON") {
digitalWrite(2, HIGH);
ledState = true;
bluetoothMonitor.send("LED turned ON");
}
else if (cmd == "LED_OFF") {
digitalWrite(2, LOW);
ledState = false;
bluetoothMonitor.send("LED turned OFF");
}
else if (cmd == "STATUS") {
showStatus();
}
else if (cmd == "HEAP") {
bluetoothMonitor.send("Free heap: " + String(ESP.getFreeHeap()) + " bytes");
}
else {
bluetoothMonitor.send("Unknown command: " + cmd);
bluetoothMonitor.send("Type HELP for available commands");
}
}
void showStatus() {
bluetoothMonitor.send("=== System Status ===");
bluetoothMonitor.send("LED State: " + String(ledState ? "ON" : "OFF"));
unsigned long uptime = millis() / 1000;
bluetoothMonitor.send("Uptime: " + String(uptime / 3600) + "h " + String((uptime % 3600) / 60) + "m " + String(uptime % 60) + "s");
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("Messages Sent: " + String(messageCount));
bluetoothMonitor.send("====================");
}
void sendPeriodicUpdate() {
messageCount++;
if (messageCount % 3 == 0) {
bluetoothMonitor.send("[INFO] Heartbeat #" + String(messageCount));
}
else if (messageCount % 5 == 0) {
bluetoothMonitor.send("[HEAP] Free: " + String(ESP.getFreeHeap()) + " bytes");
}
else {
bluetoothMonitor.send("[TIME] Uptime: " + String(millis() / 1000) + "s");
}
Serial.print("Sent update #");
Serial.println(messageCount);
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
sendPeriodicUpdate();
}
delay(10);
}
- Klicken Sie auf den Upload-Button in der Arduino IDE, um den Code auf den ESP32 hochzuladen
- Öffnen Sie den Serial Monitor
- Überprüfen Sie das Ergebnis im Serial Monitor. Es sieht folgendermaßen aus:
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
DIYables Bluetooth - ESP32 BLE Monitor Example
Waiting for Bluetooth connection...
Mobile App
- Wenn Sie den ESP32 Classic Bluetooth Code verwenden, müssen Sie den ESP32 mit Ihrem Android-Telefon vor dem Öffnen der App koppeln:
- Gehen Sie zu den Einstellungen > Bluetooth Ihres Telefons
- Stellen Sie sicher, dass Bluetooth eingeschaltet ist
- Ihr Telefon scannt nach verfügbaren Geräten
- Finden und tippen Sie auf "ESP32_Monitor" in der Liste der verfügbaren Geräte
- Bestätigen Sie die Kopplungsanfrage (keine PIN erforderlich)
- Warten Sie, bis unter dem Gerätenamen "Gekoppelt" angezeigt wird
- Wenn Sie den ESP32 BLE Code verwenden, ist keine Kopplung erforderlich. Fahren Sie einfach mit dem nächsten Schritt fort.
- Öffnen Sie die DIYables Bluetooth App
- Beim ersten Öffnen der App werden Berechtigungen angefordert. Gewähren Sie bitte folgende:
- Nearby Devices-Berechtigung (Android 12+) / Bluetooth-Berechtigung (iOS) - erforderlich zum Scannen und Verbinden mit Bluetooth-Geräten
- Standort-Berechtigung (nur Android 11 und darunter) - erforderlich von älteren Android-Versionen zum Scannen nach BLE-Geräten
- Stellen Sie sicher, dass Bluetooth auf Ihrem Telefon eingeschaltet ist
- Tippen Sie auf dem Startbildschirm auf den Connect-Button. Die App scannt nach sowohl BLE- als auch Classic Bluetooth-Geräten.
- Finden und tippen Sie auf Ihr Gerät in den Scan-Ergebnissen, um sich zu verbinden:
- Für Classic Bluetooth: tippen Sie auf "ESP32_Monitor"
- Für BLE: tippen Sie auf "ESP32BLE_Monitor"
- Nach der Verbindung kehrt die App automatisch zum Startbildschirm zurück. Wählen Sie die Monitor-App aus dem App-Menü.
Hinweis: Sie können auf das Einstellungssymbol auf dem Startbildschirm tippen, um Apps auf dem Startbildschirm zu verstecken/anzeigen. Weitere Details finden Sie im DIYables Bluetooth App Benutzerhandbuch.
- Sie sehen Statusmeldungen, die in der Monitor-Anzeige gestreamt werden
- Tippen Sie LED_ON in das Eingabefeld und tippen Sie auf Send — die integrierte LED auf dem ESP32 wird eingeschaltet und der Monitor zeigt eine Bestätigungsmeldung an
Schauen Sie nun zurück zum Serial Monitor in der Arduino IDE. Sie werden sehen:
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
Bluetooth connected!
Sent update #1
Sent update #2
Received command: HELP
Received command: STATUS
- Geben Sie Befehle in die App ein (HELP, STATUS, LED_ON, LED_OFF, HEAP) und beobachten Sie die Antworten
Kreative Anpassung - Passen Sie den Code an Ihr Projekt an
Nachrichten an die App senden
Verwenden Sie die send()-Methode, um Textnachrichten an die Monitor-Anzeige zu streamen:
// Einfache Nachrichten senden
bluetoothMonitor.send("System initialized");
bluetoothMonitor.send("Sensor reading: 25.3°C");
// Formatierte Daten senden
bluetoothMonitor.send("[INFO] Heartbeat #" + String(count));
bluetoothMonitor.send("[WARN] Temperature high: " + String(temp) + "°C");
bluetoothMonitor.send("[ERROR] Sensor disconnected");
// Systeminformationen senden
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
bluetoothMonitor.send("Uptime: " + String(millis() / 1000) + " seconds");
Befehle von der App empfangen
Verwenden Sie den onMonitorMessage()-Callback, um Befehle zu empfangen, die in die Monitor-App eingegeben wurden, und darauf zu reagieren:
bluetoothMonitor.onMonitorMessage([](const String& message) {
Serial.print("Received command: ");
Serial.println(message);
if (message == "HELP") {
bluetoothMonitor.send("Available Commands:");
bluetoothMonitor.send(" LED_ON - Turn LED on");
bluetoothMonitor.send(" LED_OFF - Turn LED off");
bluetoothMonitor.send(" STATUS - Show system status");
bluetoothMonitor.send(" HEAP - Show memory info");
} else if (message == "LED_ON") {
digitalWrite(LED_BUILTIN, HIGH);
bluetoothMonitor.send("LED turned ON");
} else if (message == "LED_OFF") {
digitalWrite(LED_BUILTIN, LOW);
bluetoothMonitor.send("LED turned OFF");
} else if (message == "STATUS") {
bluetoothMonitor.send("System is running normally");
bluetoothMonitor.send("Uptime: " + String(millis() / 1000) + "s");
} else if (message == "HEAP") {
bluetoothMonitor.send("Free Heap: " + String(ESP.getFreeHeap()) + " bytes");
} else {
bluetoothMonitor.send("Unknown command: " + message);
}
});
Sie können so viele benutzerdefinierte Befehle hinzufügen, wie Sie benötigen, indem Sie weitere else if-Blöcke hinzufügen. Fügen Sie beispielsweise RELAY_ON / RELAY_OFF zur Steuerung eines Relais hinzu oder READ zum Auslösen einer Sensor-Ablesung — jedes Wort, das Sie in die App eingeben, wird zu einem Befehl.
Verbindungsereignisse behandeln
Sie können erkennen, wann sich die App mit dem ESP32 verbindet oder die Verbindung trennt:
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothMonitor.send("=== ESP32 Monitor Connected ===");
bluetoothMonitor.send("System Ready");
bluetoothMonitor.send("Type HELP for available commands");
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
if (bluetoothServer.isConnected()) {
bluetoothMonitor.send("Status update");
}
So verwenden Sie den Monitor
App-Interface-Steuerelemente
Die Monitor-Schnittstelle in der DIYables Bluetooth App bietet:
- Nachrichtenanzeige: Scrollbare Liste empfangener Nachrichten mit Auto-Scroll
- Texteingabe: Befehle unten eingeben
- Send-Button: Antippen, um den eingegebenen Befehl an den ESP32 zu senden
Eingebaute Befehle
Der Beispielcode enthält diese eingebauten Befehle:
- HELP – Zeigt alle verfügbaren Befehle an
- LED_ON – Schaltet die integrierte LED ein
- LED_OFF – Schaltet die integrierte LED aus
- STATUS – Zeigt Systemstatus (LED-Zustand, Betriebszeit, Heap, gesendete Nachrichten)
- HEAP – Zeigt detaillierte Speicherinformationen
Programmierbeispiele
Grundlegendes Status-Streaming
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 3000;
int messageCount = 0;
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
messageCount++;
// Zwischen verschiedenen Statusmeldungen rotieren
if (messageCount % 3 == 0) {
bluetoothMonitor.send("[INFO] Heartbeat #" + String(messageCount));
} else if (messageCount % 5 == 0) {
bluetoothMonitor.send("[HEAP] Free: " + String(ESP.getFreeHeap()) + " bytes");
} else {
bluetoothMonitor.send("[TIME] Uptime: " + String(millis() / 1000) + "s");
}
}
delay(10);
}
Sensor-Datenlogger
#include <DHT.h>
DHT dht(4, DHT22);
unsigned long lastSensorRead = 0;
const unsigned long SENSOR_INTERVAL = 5000;
void setup() {
dht.begin();
bluetoothMonitor.onMonitorMessage([](const String& message) {
if (message == "READ") {
readAndSendSensorData();
} else if (message == "INTERVAL") {
bluetoothMonitor.send("Sensor interval: " + String(SENSOR_INTERVAL / 1000) + "s");
}
});
}
void readAndSendSensorData() {
float temp = dht.readTemperature();
float hum = dht.readHumidity();
if (!isnan(temp) && !isnan(hum)) {
bluetoothMonitor.send("Temp: " + String(temp, 1) + "°C | Humidity: " + String(hum, 1) + "%");
} else {
bluetoothMonitor.send("[ERROR] Failed to read sensor");
}
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastSensorRead >= SENSOR_INTERVAL) {
lastSensorRead = millis();
readAndSendSensorData();
}
delay(10);
}
Multi-Sensor Dashboard
void sendDashboard() {
bluetoothMonitor.send("========== DASHBOARD ==========");
bluetoothMonitor.send("Temp: " + String(readTemperature(), 1) + "°C");
bluetoothMonitor.send("Humidity: " + String(readHumidity(), 0) + "%");
bluetoothMonitor.send("Light: " + String(analogRead(34)));
bluetoothMonitor.send("Battery: " + String(readBatteryVoltage(), 2) + "V");
bluetoothMonitor.send("Heap: " + String(ESP.getFreeHeap()) + " bytes");
unsigned long uptime = millis() / 1000;
bluetoothMonitor.send("Uptime: " + String(uptime / 3600) + "h " +
String((uptime % 3600) / 60) + "m " +
String(uptime % 60) + "s");
bluetoothMonitor.send("===============================");
}
GPIO-Pin Monitor
const int MONITOR_PINS[] = {16, 17, 18, 19, 21, 22};
const int NUM_PINS = 6;
int lastPinStates[6] = {0};
void setup() {
for (int i = 0; i < NUM_PINS; i++) {
pinMode(MONITOR_PINS[i], INPUT_PULLUP);
lastPinStates[i] = digitalRead(MONITOR_PINS[i]);
}
bluetoothMonitor.onMonitorMessage([](const String& message) {
if (message == "PINS") {
for (int i = 0; i < NUM_PINS; i++) {
int state = digitalRead(MONITOR_PINS[i]);
bluetoothMonitor.send("Pin " + String(MONITOR_PINS[i]) + ": " +
String(state ? "HIGH" : "LOW"));
}
}
});
}
void loop() {
bluetoothServer.loop();
// Pin-Änderungen erkennen und melden
for (int i = 0; i < NUM_PINS; i++) {
int state = digitalRead(MONITOR_PINS[i]);
if (state != lastPinStates[i]) {
lastPinStates[i] = state;
if (bluetooth.isConnected()) {
bluetoothMonitor.send("[PIN] GPIO " + String(MONITOR_PINS[i]) +
" changed to " + String(state ? "HIGH" : "LOW"));
}
}
}
delay(10);
}
Erweiterte Programmiertechniken
Kategorisierte Protokollierung
enum LogLevel { LOG_INFO, LOG_WARN, LOG_ERROR, LOG_DEBUG };
void sendLog(LogLevel level, const String& message) {
String prefix;
switch (level) {
case LOG_INFO: prefix = "[INFO] "; break;
case LOG_WARN: prefix = "[WARN] "; break;
case LOG_ERROR: prefix = "[ERROR] "; break;
case LOG_DEBUG: prefix = "[DEBUG] "; break;
}
bluetoothMonitor.send(prefix + message);
}
// Verwendung:
sendLog(LOG_INFO, "System started");
sendLog(LOG_WARN, "Battery low: " + String(voltage, 2) + "V");
sendLog(LOG_ERROR, "Sensor read failed");
sendLog(LOG_DEBUG, "Loop time: " + String(loopTime) + "ms");
Befehlsbasierte Konfiguration
int sensorInterval = 3000;
bool verboseMode = false;
bluetoothMonitor.onMonitorMessage([](const String& message) {
String cmd = message;
cmd.toUpperCase();
if (cmd.startsWith("SET INTERVAL ")) {
sensorInterval = cmd.substring(13).toInt() * 1000;
bluetoothMonitor.send("Interval set to " + String(sensorInterval / 1000) + "s");
} else if (cmd == "VERBOSE ON") {
verboseMode = true;
bluetoothMonitor.send("Verbose mode enabled");
} else if (cmd == "VERBOSE OFF") {
verboseMode = false;
bluetoothMonitor.send("Verbose mode disabled");
} else if (cmd == "CONFIG") {
bluetoothMonitor.send("Interval: " + String(sensorInterval / 1000) + "s");
bluetoothMonitor.send("Verbose: " + String(verboseMode ? "ON" : "OFF"));
}
});
Hardware-Integrationsbeispiele
Watchdog Monitor
unsigned long lastLoopTime = 0;
unsigned long maxLoopTime = 0;
int warningCount = 0;
void loop() {
unsigned long loopStart = millis();
bluetoothServer.loop();
// Hier ist Ihr Anwendungscode
performTasks();
unsigned long loopTime = millis() - loopStart;
if (loopTime > maxLoopTime) {
maxLoopTime = loopTime;
}
if (loopTime > 100) { // Warnung wenn Loop >100ms dauert
warningCount++;
if (bluetooth.isConnected()) {
bluetoothMonitor.send("[WARN] Slow loop: " + String(loopTime) + "ms");
}
}
delay(10);
}
BLE vs Classic Bluetooth - Welches soll ich wählen?
| Funktion | BLE (Esp32BLE_Monitor) | Classic Bluetooth (Esp32Bluetooth_Monitor) |
|---|---|---|
| iOS-Unterstützung | ✓ Ja | ✗ Nein |
| Android-Unterstützung | ✓ Ja | ✓ Ja |
| Stromverbrauch | Niedrig | Höher |
| Reichweite | ~30-100m | ~10-100m |
| Datenrate | Niedriger | Höher |
| Kopplung erforderlich | Nein (Auto-Connect) | Ja (manuelle Kopplung) |
| Am besten für | Batteriebetrieben, plattformübergreifend | Hoher Durchsatz, nur Android |
Fehlerbehebung
Häufige Probleme
1. Gerät kann in der App nicht gefunden werden
- Stellen Sie sicher, dass der ESP32 eingeschaltet ist und der Sketch hochgeladen wurde
- Für BLE: Stellen Sie sicher, dass Bluetooth und Standort Ihres Telefons aktiviert sind
- Für Classic Bluetooth: Koppeln Sie das Gerät zuerst in den Bluetooth-Einstellungen des Telefons
- Überprüfen Sie, ob das korrekte Partition Scheme ausgewählt ist (Huge APP)
2. Nachrichten erscheinen nicht im Monitor
- Überprüfen Sie den Bluetooth-Verbindungsstatus in der App
- Verifizieren Sie die Verbindung im Serial Monitor
- Stellen Sie sicher, dass Nachrichten mit bluetoothMonitor.send() gesendet werden
- Versuchen Sie, die Verbindung zu trennen und wieder zu verbinden
3. Befehle werden nicht empfangen
- Überprüfen Sie, ob der onMonitorMessage()-Callback korrekt eingerichtet ist
- Prüfen Sie den Serial Monitor auf empfangene Befehle
- Stellen Sie sicher, dass der Monitor-App-Bildschirm in der mobilen App ausgewählt ist
4. Verbindung bricht häufig ab
- Bewegen Sie sich näher zum ESP32 (Entfernung reduzieren)
- Für BLE: Überprüfen Sie auf Interferenzen von anderen BLE-Geräten
- Für Classic Bluetooth: Stellen Sie eine stabile Stromversorgung des ESP32 sicher
- Reduzieren Sie die Nachrichtenfrequenz, wenn Sie zu schnell senden
5. Nachrichten erscheinen verstümmelt oder abgeschnitten
- Halten Sie einzelne Nachrichten kurz (unter 200 Zeichen)
- Fügen Sie kleine Verzögerungen zwischen schnellen Sendungen hinzu
- Überprüfen Sie den freien Heap-Speicher auf Pufferprobleme
6. Sketch zu groß / nicht genügend Speicherplatz
- Gehen Sie in der Arduino IDE zu Tools > Partition Scheme und wählen Sie "Huge APP (3MB No OTA/1MB SPIFFS)" oder "No OTA (Large APP)"
- Das Standard-Partition Scheme bietet nur ~1,2MB für App-Code, was für Bluetooth-Bibliotheken nicht ausreicht
- Diese Einstellung gibt ~3MB durch Opfern der OTA (Over-the-Air Update) Partition
Debug-Tipps
Umfassendes Debugging hinzufügen:
void debugMonitorStatus() {
Serial.println("=== Monitor Debug ===");
Serial.println("Connected: " + String(bluetooth.isConnected()));
Serial.println("Messages sent: " + String(messageCount));
Serial.println("Free Heap: " + String(ESP.getFreeHeap()));
Serial.println("=====================");
}
Projektideen
Debugging-Projekte
- Kabelloser Serial Monitor-Ersatz
- Remote-Sensor-Daten-Viewer
- Echtzeit-Variableninspektion
- Systemleistungsüberwachung
Überwachungsprojekte
- Wetterstation-Datenanzeige
- Hausautomationssystem-Status
- Industrielle Sensorüberwachung
- IoT-Gerätezustands-Dashboard
Protokollierungsprojekte
- Event-Logger mit Zeitstempeln
- Sensor-Datenaufzeichnung
- Fehlerverfolgung und Alarmierung
- Leistungsprofilerstellung
Bildungsprojekte
- Bluetooth-Kommunikation lernen
- Serial-ähnliche Nachrichten üben
- Embedded-System-Monitoring verstehen
- Benutzerdefinierte Debugging-Tools entwickeln
Integration mit anderen Bluetooth-Apps
Kombination mit Bluetooth Chat
Verwenden Sie Monitor für kontinuierliche Ausgabe und Chat für interaktive Befehle:
// Monitor streamt automatisch Sensordaten
void loop() {
if (bluetooth.isConnected() && millis() - lastUpdate >= 3000) {
bluetoothMonitor.send("[SENSOR] " + String(readSensor()));
}
}
// Chat behandelt interaktive Befehle
bluetoothChat.onChatMessage([](const String& message) {
if (message == "read") {
bluetoothChat.send("Value: " + String(readSensor()));
}
});
Kombination mit Bluetooth Slider
Verwenden Sie Monitor zur Echtzeitanzeige von Slider-Werten:
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
bluetoothMonitor.send("Slider1=" + String(slider1) + "% Slider2=" + String(slider2) + "%");
bluetoothMonitor.send("PWM1=" + String(map(slider1, 0, 100, 0, 255)) +
" PWM2=" + String(map(slider2, 0, 100, 0, 255)));
});
Nächste Schritte
Nachdem Sie das Bluetooth Monitor-Beispiel gemeistert haben, probieren Sie:
- Bluetooth Chat - Für interaktives bidirektionales Messaging
- Bluetooth Table - Für strukturierte Datenanzeige
- Bluetooth Plotter - Für grafische Datenvisualisierung
- Multiple Bluetooth Apps - Kombination von Monitor mit anderen Steuerungen
Support
Für zusätzliche Hilfe:
- Überprüfen Sie die API-Referenzdokumentation
- Besuchen Sie DIYables Tutorials
- Arduino Community-Foren