ESP32 Bluetooth Analog Gauge Beispiel - Analog Gauge Display Tutorial
Überblick
Das Bluetooth Analog Gauge Beispiel bietet eine klassische analoge Messgerät-Anzeige, 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. Senden Sie numerische Werte mit konfigurierbarem Bereich und Einheitenbeschriftungen — perfekt für Tachometer, Druckmessgeräte, Voltmeter und jede Anwendung, die eine analoge Skalen-Anzeige benötigt.
Dieses Beispiel unterstützt zwei Bluetooth-Modi:
- ESP32 BLE (Bluetooth Low Energy): Funktioniert auf Android und 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
- Analog Gauge Display: Klassische Zifferblatt-/Messgerät-Visualisierung
- Konfigurierbarer Bereich: Setzen Sie Mindest- und Höchstwerte für die Anzeige
- Benutzerdefinierte Einheiten: Zeigen Sie km/h, PSI, V, % oder beliebige Einheitenstrings an
- Echtzeit-Updates: Senden Sie Live-Messwerte mit sanfter Zeigerbewegung
- Request Callback: App kann aktuellen Wert auf Abruf anfordern
- BLE & Classic Bluetooth: Wählen Sie den Bluetooth-Modus, der zu Ihrem Projekt passt
- Cross-Platform: BLE-Modus funktioniert auf Android und iOS; Classic Bluetooth funktioniert auf Android
- Low Power Option: 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 (30 Sensoren/Displays) | |
| 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
Befolgen Sie diese Anweisungen Schritt für Schritt:
- Neu bei ESP32? Beginnen Sie mit unserem Tutorial zur Einrichtung der Umgebung für ESP32 in der Arduino IDE, um zuerst die Grundlagen zu lernen.
- 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", dann finden Sie die DIYables Bluetooth Bibliothek von DIYables
- Klicken Sie auf den Install Button, um die Bibliothek zu installieren.
- Sie werden nach der Installation einiger anderer Bibliotheksabhängigkeiten gefragt
- 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_AnalogGauge 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 Analog Gauge 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 Analog Gauge feature:
* - Display values on an analog meter/gauge
* - Configurable range and unit
* - Perfect for sensor monitoring (speed, pressure, voltage, etc.)
*
* 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
*
* Optional: Analog sensor (potentiometer, pressure sensor, etc.)
*
* 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 the gauge
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothAnalogGauge.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Gauge");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Analog Gauge app instance (min=0, max=100, unit="km/h")
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 100.0, "km/h");
// Variables for gauge value
float currentValue = 0.0;
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 200; // Update every 200ms
// Optional: Analog input pin for sensor
const int ANALOG_PIN = 34; // ESP32 ADC pin
// Function to read sensor value
float readSensorValue() {
// TODO: Replace with actual sensor reading
// Examples:
// - Pressure sensor: readPressure()
// - Voltage sensor: analogRead(34) * (3.3 / 4095.0)
// - Speed sensor: calculateSpeed()
// Option 1: Read from analog pin and map to gauge range
// int rawValue = analogRead(ANALOG_PIN);
// return map(rawValue, 0, 4095, 0, 100);
// Option 2: Simulated data (sine wave)
static float phase = 0;
phase += 0.05;
if (phase > 2 * PI) phase = 0;
return 50 + 50 * sin(phase); // Oscillates between 0-100
}
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Analog Gauge Example");
// Optional: Initialize analog pin
// pinMode(ANALOG_PIN, INPUT);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add gauge app to server
bluetoothServer.addApp(&bluetoothGauge);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Send initial value
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Initial value sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Optional: Handle requests for current value
bluetoothGauge.onValueRequest([]() {
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Value requested - Sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
// You can change gauge configuration at runtime:
// bluetoothGauge.setRange(0.0, 200.0); // Change range to 0-200
// bluetoothGauge.setUnit("mph"); // Change unit to mph
// bluetoothGauge.setRange(0.0, 3.3); // For voltage (0-3.3V on ESP32)
// bluetoothGauge.setUnit("V");
Serial.println("Waiting for Bluetooth connection...");
Serial.print("Gauge range: ");
Serial.print(bluetoothGauge.getMin());
Serial.print(" - ");
Serial.print(bluetoothGauge.getMax());
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
// Send gauge updates periodically (only when connected)
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
// Read sensor value
currentValue = readSensorValue();
// Send to Bluetooth app
bluetoothGauge.send(currentValue);
// Print to Serial Monitor
Serial.print("Gauge: ");
Serial.print(currentValue, 1);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
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:
COM6
DIYables Bluetooth - ESP32 Analog Gauge Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
ESP32 BLE Code (funktioniert mit der App auf Android und iOS)
- Gehen Sie in der Arduino IDE zu File Examples DIYables Bluetooth Esp32BLE_AnalogGauge Beispiel, oder kopieren Sie den obigen Code und fügen Sie ihn in den Editor der Arduino IDE ein
/*
* DIYables Bluetooth Library - ESP32 BLE Analog Gauge Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Analog Gauge feature:
* - Display values on an analog meter/gauge
* - Configurable range and unit
* - Perfect for sensor monitoring (speed, pressure, voltage, etc.)
*
* 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
*
* Optional: Analog sensor (potentiometer, pressure sensor, etc.)
*
* 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 the gauge
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothAnalogGauge.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Gauge";
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 Analog Gauge app instance (min=0, max=100, unit="km/h")
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 100.0, "km/h");
// Variables for gauge value
float currentValue = 0.0;
unsigned long lastUpdate = 0;
const unsigned long UPDATE_INTERVAL = 200; // Update every 200ms
// Optional: Analog input pin for sensor
const int ANALOG_PIN = 34; // ESP32 ADC pin
// Function to read sensor value
float readSensorValue() {
// TODO: Replace with actual sensor reading
// Option 1: Read from analog pin and map to gauge range
// int rawValue = analogRead(ANALOG_PIN);
// return map(rawValue, 0, 4095, 0, 100); // ESP32 has 12-bit ADC
// Option 2: Simulated data (sine wave)
static float phase = 0;
phase += 0.05;
if (phase > 2 * PI) phase = 0;
return 50 + 50 * sin(phase); // Oscillates between 0-100
}
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Analog Gauge Example");
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add gauge app to server
bluetoothServer.addApp(&bluetoothGauge);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Initial value sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
bluetoothGauge.onValueRequest([]() {
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Value requested - Sent: ");
Serial.print(currentValue);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
});
Serial.println("Waiting for Bluetooth connection...");
Serial.print("Gauge range: ");
Serial.print(bluetoothGauge.getMin());
Serial.print(" - ");
Serial.print(bluetoothGauge.getMax());
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
void loop() {
bluetoothServer.loop();
if (bluetooth.isConnected() && millis() - lastUpdate >= UPDATE_INTERVAL) {
lastUpdate = millis();
currentValue = readSensorValue();
bluetoothGauge.send(currentValue);
Serial.print("Gauge: ");
Serial.print(currentValue, 1);
Serial.print(" ");
Serial.println(bluetoothGauge.getUnit());
}
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:
COM6
DIYables Bluetooth - ESP32 BLE Analog Gauge Example
Waiting for Bluetooth connection...
Autoscroll
Clear output
9600 baud
Newline
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_Gauge" in der Liste der verfügbaren Geräte
- Bestätigen Sie die Kopplungsanfrage (keine PIN erforderlich)
- Warten Sie, bis "Gekoppelt" unter dem Gerätenamen 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 Sie nach Berechtigungen gefragt. Bitte gewähren Sie folgende:
- Nearby Devices Berechtigung (Android 12+) / Bluetooth Berechtigung (iOS) - erforderlich zum Scannen und Verbinden mit Bluetooth-Geräten
- Location Berechtigung (nur Android 11 und älter) - von älteren Android-Versionen zum Scannen nach BLE-Geräten benötigt
- Stellen Sie sicher, dass Bluetooth auf Ihrem Telefon eingeschaltet ist
- Tippen Sie auf dem Startbildschirm auf den Connect Button. Die App scannt nach BLE- und 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_Gauge"
- Für BLE: tippen Sie auf "ESP32BLE_Gauge"
- Nach der Verbindung kehrt die App automatisch zum Startbildschirm zurück. Wählen Sie die Analog Gauge App aus dem App-Menü.
Hinweis: Sie können das Einstellungssymbol auf dem Startbildschirm antippen, um Apps auf dem Startbildschirm aus-/einzublenden. Für weitere Details siehe das DIYables Bluetooth App Benutzerhandbuch.
- Die analoge Anzeige zeigt den aktuellen Wert mit einem sich bewegenden Zeiger an
Schauen Sie nun zurück auf den Serial Monitor in der Arduino IDE. Sie werden sehen:
COM6
Bluetooth connected!
Gauge value: 50.0 km/h
Gauge value: 75.0 km/h
Gauge value: 93.3 km/h
Gauge value: 100.0 km/h
Autoscroll
Clear output
9600 baud
Newline
- Beobachten Sie, wie sich der Zeiger der Anzeige in Echtzeit in der App bewegt
Kreative Anpassung - Den Code an Ihr Projekt anpassen
Bereich und Einheit der Anzeige konfigurieren
Setzen Sie den Anzeigebereich und die Einheit:
// Constructor: DIYables_BluetoothAnalogGauge(min, max, unit)
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 100.0, "km/h");
// Bereich zur Laufzeit ändern
bluetoothGauge.setRange(0.0, 200.0);
// Einheit ändern
bluetoothGauge.setUnit("MPH");
// Aktuelle Konfiguration lesen
float minVal = bluetoothGauge.getMin(); // Returns 0.0
float maxVal = bluetoothGauge.getMax(); // Returns 100.0
String unit = bluetoothGauge.getUnit(); // Returns "km/h"
Gauge Wert senden
// Aktuelle Messung senden
float speed = 72.5;
bluetoothGauge.send(speed);
// Textnachricht senden
bluetoothGauge.send("Kalibrierung...");
Wertanfragen von der App verarbeiten
bluetoothGauge.onValueRequest([]() {
float currentValue = readSensor();
bluetoothGauge.send(currentValue);
Serial.println("App hat Wert angefordert: " + String(currentValue));
});
Verbindungsereignisse verarbeiten
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth verbunden!");
bluetoothGauge.send(currentValue); // Aktuelle Messung senden
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth getrennt!");
});
Verwendung der Analog Gauge
App-Interface
Das Analog Gauge Interface in der DIYables Bluetooth App zeigt:
- Zifferblatt/Zeiger: Klassisches analoges Messgerät mit beweglichem Zeiger
- Numerische Anzeige: Zeigt den exakten aktuellen Wert
- Einheitenbeschriftung: Zeigt den konfigurierten Einheitenstring an
- Skalenmarkierungen: Zeigt abgestufte Skala von Minimum bis Maximum
Häufige Einheitenkonfigurationen
- Geschwindigkeit: DIYables_BluetoothAnalogGauge(0.0, 200.0, "km/h")
- Druck: DIYables_BluetoothAnalogGauge(0.0, 100.0, "PSI")
- Spannung: DIYables_BluetoothAnalogGauge(0.0, 5.0, "V")
- Prozent: DIYables_BluetoothAnalogGauge(0.0, 100.0, "%")
- RPM: DIYables_BluetoothAnalogGauge(0.0, 8000.0, "RPM")
Programmierbeispiele
Voltmeter
const int VOLTAGE_PIN = 34;
const float VREF = 3.3;
const float DIVIDER_RATIO = 5.0; // Spannungsteiler-Verhältnis
// Gauge für 0-16V Bereich konfiguriert
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 16.0, "V");
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 500) {
lastUpdate = millis();
int raw = analogRead(VOLTAGE_PIN);
float voltage = (raw / 4095.0) * VREF * DIVIDER_RATIO;
bluetoothGauge.send(voltage);
Serial.println("Spannung: " + String(voltage, 2) + " V");
}
delay(10);
}
Druckmesser (BMP280)
#include <Adafruit_BMP280.h>
Adafruit_BMP280 bmp;
// Gauge für atmosphärischen Druckbereich konfiguriert
DIYables_BluetoothAnalogGauge bluetoothGauge(900.0, 1100.0, "hPa");
void setup() {
Serial.begin(115200);
bmp.begin(0x76);
// ... Bluetooth Setup ...
bluetoothGauge.onValueRequest([]() {
float pressure = bmp.readPressure() / 100.0; // Pa zu hPa
bluetoothGauge.send(pressure);
});
}
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 1000) {
lastUpdate = millis();
float pressure = bmp.readPressure() / 100.0;
bluetoothGauge.send(pressure);
Serial.println("Druck: " + String(pressure, 1) + " hPa");
}
delay(10);
}
Stromsensor (ACS712)
const int CURRENT_PIN = 34;
const float SENSITIVITY = 0.185; // ACS712-05B: 185mV/A
const float ZERO_CURRENT_VOLTAGE = 2.5;
// Gauge für 0-5A Bereich konfiguriert
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 5.0, "A");
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 200) {
lastUpdate = millis();
int raw = analogRead(CURRENT_PIN);
float voltage = (raw / 4095.0) * 3.3;
float current = abs((voltage - ZERO_CURRENT_VOLTAGE) / SENSITIVITY);
bluetoothGauge.send(current);
Serial.println("Strom: " + String(current, 2) + " A");
}
delay(10);
}
Geschwindigkeit vom Encoder
volatile unsigned long pulseCount = 0;
const int ENCODER_PIN = 2;
const float PULSES_PER_REV = 20.0;
const float WHEEL_CIRCUMFERENCE = 0.628; // Meter (20cm Durchmesser)
DIYables_BluetoothAnalogGauge bluetoothGauge(0.0, 50.0, "km/h");
void IRAM_ATTR countPulse() {
pulseCount++;
}
void setup() {
Serial.begin(115200);
pinMode(ENCODER_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(ENCODER_PIN), countPulse, RISING);
// ... Bluetooth Setup ...
}
void loop() {
bluetoothServer.loop();
static unsigned long lastCalc = 0;
if (millis() - lastCalc >= 500) {
unsigned long elapsed = millis() - lastCalc;
lastCalc = millis();
noInterrupts();
unsigned long count = pulseCount;
pulseCount = 0;
interrupts();
float revPerSec = (count / PULSES_PER_REV) / (elapsed / 1000.0);
float speedKmh = revPerSec * WHEEL_CIRCUMFERENCE * 3.6;
bluetoothGauge.send(speedKmh);
Serial.println("Geschwindigkeit: " + String(speedKmh, 1) + " km/h");
}
delay(10);
}
Fortgeschrittene Programmiertechniken
Sanfte Zeigerbewegung
float displayValue = 0;
float targetValue = 0;
const float SMOOTHING = 0.1; // 0.0-1.0, niedriger = sanfter
void loop() {
bluetoothServer.loop();
static unsigned long lastUpdate = 0;
if (millis() - lastUpdate >= 50) { // 20 FPS
lastUpdate = millis();
targetValue = readSensor();
displayValue += (targetValue - displayValue) * SMOOTHING;
bluetoothGauge.send(displayValue);
}
delay(5);
}
Peak Hold (Spitzenwert halten)
float peakValue = 0;
unsigned long peakTime = 0;
const unsigned long PEAK_HOLD_MS = 3000; // Spitzenwert für 3 Sekunden halten
void updateWithPeakHold(float value) {
if (value > peakValue) {
peakValue = value;
peakTime = millis();
}
if (millis() - peakTime > PEAK_HOLD_MS) {
peakValue = value; // Spitzenwert zurücksetzen
}
// Den höheren Wert von aktuell oder Spitzenwert senden
bluetoothGauge.send(max(value, peakValue));
}
Automatische Bereichsskalierung
float autoMin = 0;
float autoMax = 100;
void autoScale(float value) {
bool changed = false;
if (value < autoMin) {
autoMin = value - 10;
changed = true;
}
if (value > autoMax) {
autoMax = value + 10;
changed = true;
}
if (changed) {
bluetoothGauge.setRange(autoMin, autoMax);
}
bluetoothGauge.send(value);
}
Hardware-Integrations-Ideen
Analoge Sensoren
Jeder Sensor mit analogem Ausgang kann die Anzeige antreiben: Potentiometer, Kraftsensoren, Flex-Sensoren und mehr.
I2C/SPI Sensoren
Verwenden Sie I2C-Sensoren wie BMP280 (Druck), INA219 (Strom/Leistung), oder SPI-Sensoren für Hochgeschwindigkeitsmessungen.
Puls-/Frequenzsensoren
Geschwindigkeitsencoder, Durchflussmesser und RPM-Sensoren mit interrupt-basierter Zählung.
Wägezellen (HX711)
Gewichtsmessung mit dem HX711-Verstärker für Küchenwaagen oder industrielle Wägungen.
BLE vs Classic Bluetooth - Welches wählen?
| Feature | BLE (Esp32BLE_AnalogGauge) | Classic Bluetooth (Esp32Bluetooth_AnalogGauge) |
|---|---|---|
| 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 (automatische Verbindung) | Ja (manuelle Kopplung) |
| Am besten für | Batteriebetrieben, Cross-Platform | Hoher Durchsatz, nur Android |
Fehlerbehebung
Häufige Probleme
1. Kann das Gerät in der App nicht finden
- 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, dass das korrekte Partition Schema ausgewählt ist (Huge APP)
2. Anzeige zeigt 0 oder falschen Wert
- Überprüfen Sie die Sensor-Verkabelung und Verbindungen
- Prüfen Sie die Sensor-Ablesung zuerst mit dem Serial Monitor
- Stellen Sie sicher, dass der Wert im konfigurierten Bereich liegt
- Überprüfen Sie die Einheit und Bereichskonfiguration im Constructor
3. Zeiger der Anzeige bewegt sich nicht sanft
- Erhöhen Sie die Update-Frequenz (kleineres Intervall in der millis() Prüfung)
- Wenden Sie Glättung/Filterung auf Sensor-Ablesungen an
- Prüfen Sie auf Sensor-Rauschen oder instabile Ablesungen
4. Werte außerhalb des Anzeigebereichs
- Passen Sie den Bereich mit setRange(min, max) an Ihre Sensor-Ausgabe an
- Werte außerhalb des Bereichs werden angezeigt, aber möglicherweise bei min/max abgeschnitten
- Erwägen Sie automatische Skalierung für unbekannte Bereiche
5. Verbindung bricht häufig ab
- Kommen Sie näher zum ESP32 (Entfernung reduzieren)
- Für BLE: Prüfen Sie auf Interferenzen von anderen BLE-Geräten
- Für Classic Bluetooth: Stellen Sie stabile Stromversorgung des ESP32 sicher
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 Schema bietet nur ~1,2MB für App-Code, was für Bluetooth-Bibliotheken nicht ausreicht
- Diese Einstellung gibt ~3MB durch Verzicht auf die OTA (Over-the-Air Update) Partition
Debug-Tipps
Fügen Sie umfassendes Debugging hinzu:
void debugGauge(float value) {
Serial.println("=== Gauge Debug ===");
Serial.println("Wert: " + String(value, 2) + " " + bluetoothGauge.getUnit());
Serial.println("Bereich: " + String(bluetoothGauge.getMin(), 1) + " - " + String(bluetoothGauge.getMax(), 1));
Serial.println("Im Bereich: " + String(value >= bluetoothGauge.getMin() && value <= bluetoothGauge.getMax() ? "Ja" : "Nein"));
float percentage = (value - bluetoothGauge.getMin()) / (bluetoothGauge.getMax() - bluetoothGauge.getMin()) * 100.0;
Serial.println("Prozent: " + String(percentage, 1) + "%");
Serial.println("===================");
}
Projektideen
Fahrzeug & Bewegung
- Tachometer für RC-Auto oder Fahrrad
- RPM-Drehzahlmesser für Motoren
- G-Kraft-Messer für Beschleunigung
- Neigungswinkel-Anzeige
Elektrisch & Leistung
- Voltmeter (Batteriespannungsüberwachung)
- Amperemeter (Stromverbrauch)
- Wattmeter (Leistungsverbrauch)
- Batteriestand-Anzeige
Umwelt
- Barometrischer Druckmesser
- Windgeschwindigkeit (Anemometer)
- UV-Index-Messer
- Schallpegelmesser (dB)
Industrie
- Waagen-Anzeige
- Durchflussmesser
- Tanklevel-Anzeige
- Drehmomentmesser
Integration mit anderen Bluetooth Apps
Kombination mit Bluetooth Temperature
Anzeige für eine Metrik, Temperatur für eine andere:
// Anzeige zeigt Druck
bluetoothGauge.send(pressure);
// Temperature zeigt Temperatur
bluetoothTemperature.send(temperature);
Kombination mit Bluetooth Table
Anzeige für Visual, Tabelle für Details:
float speed = readSpeed();
bluetoothGauge.send(speed);
bluetoothTable.sendValueUpdate("Geschwindigkeit", String(speed, 1) + " km/h");
bluetoothTable.sendValueUpdate("Entfernung", String(totalDistance, 2) + " km");
bluetoothTable.sendValueUpdate("Max Geschwindigkeit", String(maxSpeed, 1) + " km/h");
bluetoothTable.sendValueUpdate("Durchschnittsgeschwindigkeit", String(avgSpeed, 1) + " km/h");
Nächste Schritte
Nach dem Beherrschen des Bluetooth Analog Gauge Beispiels, versuchen Sie:
- Bluetooth Temperature - Für dedizierte Temperaturanzeige
- Bluetooth Plotter - Für Trend-Visualisierung über Zeit
- Bluetooth Table - Für strukturierte Multi-Wert-Anzeige
- Mehrere Bluetooth Apps - Kombination von Anzeige mit anderen Displays
Support
Für zusätzliche Hilfe:
- Überprüfen Sie die API-Referenz-Dokumentation
- Besuchen Sie DIYables Tutorials
- Arduino Community Foren