ESP32 Bluetooth Slider Voorbeeld - Dual Slider Bediening Interface Tutorial
Overzicht
Het Bluetooth Slider voorbeeld biedt twee onafhankelijke schuifregelaars die toegankelijk zijn via de DIYables Bluetooth STEM-app. Ontworpen voor ESP32 boards met ondersteuning voor zowel BLE (Bluetooth Low Energy) als Classic Bluetooth verbindingen. Elke slider geeft waarden van 0-100, wat ze perfect maakt voor PWM-besturing, helderheidsregeling, motorsnelheidsregeling en elk ander project dat analoge-achtige controlwaarden vereist.
Dit voorbeeld ondersteunt twee Bluetooth-modi:
- ESP32 BLE (Bluetooth Low Energy): werkt op zowel Android als iOS
- ESP32 Classic Bluetooth: werkt alleen op Android. iOS ondersteunt geen Classic Bluetooth. Gebruik BLE als u iOS-ondersteuning nodig heeft.
Kenmerken
- Dubbele Sliders: Twee onafhankelijke schuifregelaars (bereik 0-100 elk)
- Realtime Waarden: Directe waarde-updates via Bluetooth-communicatie
- PWM Compatibel: Waarden (0-100) makkelijk te mappen naar analogWrite() functies
- Visuele Feedback: Realtime waardewaardeweergave voor elke slider in de app
- BLE & Classic Bluetooth: Kies de Bluetooth-modus die bij uw project past
- Cross-Platform: BLE modus werkt op Android en iOS; Classic Bluetooth werkt op Android alleen
- Laag Vermogensverbruik: BLE gebruikt minder energie dan Classic Bluetooth
- Configureerbaar Bereik & Stapgrootte: Pas sliderbereik en stapgrootte aan tijdens runtime
Benodigde Hardware
Of u kunt de volgende kits kopen:
| 1 | × | DIYables Sensorkit (18 sensoren/displays) |
Openbaarmaking: Sommige van de links in deze sectie zijn Amazon-affiliate links. We kunnen een commissie ontvangen voor aankopen die via deze links worden gedaan, zonder extra kosten voor u. We waarderen uw steun.
ESP32 Code
Snelle Stappen
Volg deze instructies stap voor stap:
- Als dit uw eerste keer is met ESP32, raadpleeg dan de tutorial over het opzetten van de Arduino IDE-omgeving voor ESP32.
- Verbind het ESP32-board met uw computer via een USB-kabel.
- Start de Arduino IDE op uw computer.
- Selecteer het juiste ESP32-board en de juiste COM-poort.
- Ga naar het Libraries icoon in de linkerbalk van de Arduino IDE.
- Zoek naar "DIYables Bluetooth" en zoek dan de DIYables Bluetooth bibliotheek van DIYables.
- Klik op de Install knop om de bibliotheek te installeren.
- Er wordt gevraagd om aanvullende bibliotheekafhankelijkheden te installeren.
- Klik op de Install All knop om alle afhankelijkheden te installeren.
Kies een van de twee Bluetooth-modi hieronder, afhankelijk van uw wensen:
ESP32 Classic Bluetooth Code (werkt alleen met app op Android)
Let op: Classic Bluetooth wordt NIET ondersteund op iOS. Heeft u iOS-ondersteuning nodig, gebruik dan de BLE-code hieronder.
- In de Arduino IDE, ga naar Bestand Voorbeelden DIYables Bluetooth Esp32Bluetooth_Slider, of kopieer de bovenstaande code en plak deze in de editor van de Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 Classic Bluetooth Slider 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 Slider feature:
* - Control values using sliders (0-100)
* - Support for dual sliders
* - Configurable range and step
*
* 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 control sliders
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothSlider.h>
#include <platforms/DIYables_Esp32Bluetooth.h>
// Create Bluetooth instances
DIYables_Esp32Bluetooth bluetooth("ESP32_Slider");
DIYables_BluetoothServer bluetoothServer(bluetooth);
// Create Slider app instance (min=0, max=100, step=1)
DIYables_BluetoothSlider bluetoothSlider(0, 100, 1);
// Variables to store current slider values
int currentSlider1 = 0;
int currentSlider2 = 0;
// PWM output pins (for LED brightness control example)
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
// ESP32 LEDC PWM channels
const int PWM_CHANNEL_1 = 0;
const int PWM_CHANNEL_2 = 1;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 Slider Example");
// Initialize PWM using ESP32 LEDC
ledcSetup(PWM_CHANNEL_1, 5000, 8); // 5kHz, 8-bit resolution
ledcSetup(PWM_CHANNEL_2, 5000, 8);
ledcAttachPin(PWM_PIN_1, PWM_CHANNEL_1);
ledcAttachPin(PWM_PIN_2, PWM_CHANNEL_2);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add slider app to server
bluetoothServer.addApp(&bluetoothSlider);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Send initial slider positions
bluetoothSlider.send(currentSlider1, currentSlider2);
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up slider callback for value changes
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Store the received values
currentSlider1 = slider1;
currentSlider2 = slider2;
// Print slider values (0-100)
Serial.print("Slider 1: ");
Serial.print(slider1);
Serial.print(", Slider 2: ");
Serial.println(slider2);
// Map slider values (0-100) to PWM range (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Control LED brightness using ESP32 LEDC
ledcWrite(PWM_CHANNEL_1, pwm1);
ledcWrite(PWM_CHANNEL_2, pwm2);
// TODO: Add your control logic here based on slider values
// Examples:
// - Servo control: myServo.write(map(slider1, 0, 100, 0, 180));
// - Motor speed: ledcWrite(MOTOR_CHANNEL, pwm1);
// - Volume control: setVolume(slider1);
// - Brightness control: setBrightness(slider2);
});
// Optional: Handle requests for current slider values (when app loads)
bluetoothSlider.onGetConfig([]() {
// Send the stored slider values back to the app
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.print("App requested values - Sent: Slider1=");
Serial.print(currentSlider1);
Serial.print(", Slider2=");
Serial.println(currentSlider2);
});
// You can change slider configuration at runtime:
// bluetoothSlider.setRange(0, 255); // Change range to 0-255
// bluetoothSlider.setStep(5); // Change step to 5 (coarser control)
Serial.println("Waiting for Bluetooth connection...");
}
void loop() {
// Handle Bluetooth server communications
bluetoothServer.loop();
delay(10);
}
- Klik op de Upload knop in de Arduino IDE om de code naar de ESP32 te uploaden
- Open de Serial Monitor
- Bekijk het resultaat in de Serial Monitor. Deze ziet er als volgt uit:
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
DIYables Bluetooth - ESP32 Slider Voorbeeld
Waiting for Bluetooth connection...
ESP32 BLE Code (werkt met app op Android en iOS)
- In de Arduino IDE, ga naar Bestand Voorbeelden DIYables Bluetooth Esp32BLE_Slider, of kopieer de bovenstaande code en plak deze in de editor van Arduino IDE
/*
* DIYables Bluetooth Library - ESP32 BLE Slider Example
* Works with DIYables Bluetooth STEM app on Android and iOS
*
* This example demonstrates the Bluetooth Slider feature:
* - Control values using sliders (0-100)
* - Support for dual sliders
* - Configurable range and step
*
* 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 control sliders
*
* Tutorial: https://diyables.io/bluetooth-app
* Author: DIYables
*/
#include <DIYables_BluetoothServer.h>
#include <DIYables_BluetoothSlider.h>
#include <platforms/DIYables_Esp32BLE.h>
// BLE Configuration
const char* DEVICE_NAME = "ESP32BLE_Slider";
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 Slider app instance (min=0, max=100, step=1)
DIYables_BluetoothSlider bluetoothSlider(0, 100, 1);
// Variables to store current slider values
int currentSlider1 = 0;
int currentSlider2 = 0;
// PWM output pins
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
void setup() {
Serial.begin(115200);
delay(1000);
Serial.println("DIYables Bluetooth - ESP32 BLE Slider Example");
// Initialize PWM pins
pinMode(PWM_PIN_1, OUTPUT);
pinMode(PWM_PIN_2, OUTPUT);
// Initialize Bluetooth server with platform-specific implementation
bluetoothServer.begin();
// Add slider app to server
bluetoothServer.addApp(&bluetoothSlider);
// Set up connection event callbacks
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
bluetoothSlider.send(currentSlider1, currentSlider2);
});
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
});
// Set up slider callback for value changes
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
Serial.print("Slider 1: ");
Serial.print(slider1);
Serial.print(", Slider 2: ");
Serial.println(slider2);
// Map slider values (0-100) to PWM range (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
analogWrite(PWM_PIN_1, pwm1);
analogWrite(PWM_PIN_2, pwm2);
// TODO: Add your control logic here
});
bluetoothSlider.onGetConfig([]() {
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.print("App requested values - Sent: Slider1=");
Serial.print(currentSlider1);
Serial.print(", Slider2=");
Serial.println(currentSlider2);
});
Serial.println("Waiting for Bluetooth connection...");
}
void loop() {
bluetoothServer.loop();
delay(10);
}
- Klik op de Upload knop om de code naar de ESP32 te uploaden
- Open de Serial Monitor
- Bekijk het resultaat in de Serial Monitor. Deze ziet er als volgt uit:
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
DIYables Bluetooth - ESP32 BLE Slider Voorbeeld
Waiting for Bluetooth connection...
Mobiele App
- Als u de ESP32 Classic Bluetooth-code gebruikt, moet u de ESP32 eerst koppelen met uw Android-telefoon voordat u de app opent:
- Ga naar de Instellingen > Bluetooth van uw telefoon
- Zorg dat Bluetooth ingeschakeld is
- De telefoon zoekt naar beschikbare apparaten
- Zoek en tik op "ESP32_Slider" in de lijst met apparaten
- Bevestig het koppelverzoek (geen PIN vereist)
- Wacht tot het apparaat "Paired" weergeeft
- Als u de ESP32 BLE-code gebruikt, is koppelen niet nodig. Ga gewoon door naar de volgende stap.
- Open de DIYables Bluetooth App
- Bij het eerste openen vraagt de app om toestemming. Verleen alstublieft:
- Nearby Devices toestemming (Android 12+) / Bluetooth toestemming (iOS) - nodig om te scannen en verbinden met Bluetooth-apparaten
- Locatie toestemming (alleen Android 11 en lager) - vereist door oudere Android-versies voor BLE-scanning
- Zorg dat Bluetooth ingeschakeld is op uw telefoon
- Tik op het startscherm op de Connect knop. De app gaat zoeken naar BLE en Classic Bluetooth apparaten.
- Zoek en tik op uw apparaat in de zoekresultaten om te verbinden:
- Voor Classic Bluetooth: tik op "ESP32_Slider"
- Voor BLE: tik op "ESP32BLE_Slider"
- Nadat u verbonden bent, keert de app automatisch terug naar het startscherm. Selecteer de Slider app uit het menu.
Let op: U kunt op het instellingen-icoon op het startscherm tikken om apps te verbergen of te tonen. Voor meer informatie, zie de DIYables Bluetooth App Gebruikershandleiding.
- Beweeg de twee sliders om PWM-waarden (0-100) te regelen
Kijk nu terug naar de Serial Monitor in de Arduino IDE. U ziet het volgende:
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
Bluetooth connected!
Slider 1: 50, Slider 2: 30
Slider 1: 75, Slider 2: 30
Slider 1: 75, Slider 2: 60
Slider 1: 100, Slider 2: 85
- Beweeg de sliders in de app en kijk naar de realtime feedback in de Serial Monitor
Creatieve Aanpassing - Pas de Code aan voor uw Project
Stel Standaard Sliderwaarden in
Configureer de beginposities van de sliders:
// Huidige sliderwaarden (0-100)
int currentSlider1 = 25; // Standaard 25%
int currentSlider2 = 50; // Standaard 50%
Pas Slider Bereik en Stapgrootte aan
// Maak een Slider app instantie met aangepast bereik (min=0, max=255, stap=5)
DIYables_BluetoothSlider bluetoothSlider(0, 255, 5);
// Of wijzig tijdens runtime:
bluetoothSlider.setRange(0, 255); // Wijzig bereik naar 0-255
bluetoothSlider.setStep(5); // Wijzig stap naar 5 (grovere controle)
// Lees huidige configuratie:
int currentMin = bluetoothSlider.getMin(); // Huidige minimum waarde
int currentMax = bluetoothSlider.getMax(); // Huidige maximum waarde
int currentStep = bluetoothSlider.getStep(); // Huidige stapgrootte
Behandel Configuratieverzoek van App
Wanneer de app verbindt en het Slider scherm opent, vraagt deze om de sliderconfiguratie van de ESP32. Gebruik de callback onGetConfig() om de huidige sliderwaarden op dat moment naar de app te sturen:
bluetoothSlider.onGetConfig([]() {
// Wordt aangeroepen wanneer de app om sliderconfiguratie vraagt
// Stuur de huidige sliderwaarden zodat de app ze correct kan weergeven
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.println("App requested config - sent current values");
});
Waarden naar App Verzenden
U kunt sliderwaarden van de ESP32 naar de app sturen (bijvoorbeeld om sliderposities bij te werken):
// Verstuur beide sliderwaarden naar de app
bluetoothSlider.send(currentSlider1, currentSlider2);
// Verstuur een enkele waarde (toegepast op beide sliders)
bluetoothSlider.send(50);
Behandel Verbindingsgebeurtenissen
U kunt detecteren wanneer de app verbinding maakt of verbreekt met de ESP32:
// Wordt aangeroepen wanneer de app verbindt met de ESP32
bluetoothServer.setOnConnected([]() {
Serial.println("Bluetooth connected!");
// Verstuur huidige sliderwaarden naar de app
bluetoothSlider.send(currentSlider1, currentSlider2);
});
// Wordt aangeroepen wanneer de app de verbinding verbreekt
bluetoothServer.setOnDisconnected([]() {
Serial.println("Bluetooth disconnected!");
// Optioneel: stop motors, reset outputs, enz.
});
// Controleer verbindingstatus overal in uw code
if (bluetoothServer.isConnected()) {
// Doe iets alleen als verbonden
}
Hoe de Sliders te Gebruiken
App Interface Besturingselementen
De slider interface in de DIYables Bluetooth App biedt:
- Slider 1: Eerste regelaar met waardedisplay
- Slider 2: Tweede regelaar met waardedisplay
- Waardeweergave: Realtime numerieke waarden voor beide sliders
Waardebereiken
Elke slider levert:
- Standaard Bereik: 0 tot 100
- Configureerbaar: Bereik en stap kunnen aangepast worden in de code
- PWM Mapping: Gemakkelijk te mappen naar 0-255 voor analogWrite()
Programmeervoorbeelden
Basis Slider Handler
void setup() {
// Stel slider callback in voor waardeveranderingen
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Sla de ontvangen waarden op
currentSlider1 = slider1;
currentSlider2 = slider2;
// Print sliderwaarden
Serial.println("Slider 1: " + String(slider1) + ", Slider 2: " + String(slider2));
// Voeg hier uw besturingslogica toe
});
}
LED Helderheidsregeling (BLE Voorbeeld)
// PWM-uitgangspinnen
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
void setup() {
// Configureer PWM-pinnen als uitgangen
pinMode(PWM_PIN_1, OUTPUT);
pinMode(PWM_PIN_2, OUTPUT);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Map sliderwaarden (0-100) naar PWM-bereik (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Regel LED helderheid
analogWrite(PWM_PIN_1, pwm1);
analogWrite(PWM_PIN_2, pwm2);
Serial.println("LED1 Brightness: " + String(pwm1) +
", LED2 Brightness: " + String(pwm2));
});
}
LED Helderheidsregeling (Classic Bluetooth met ESP32 LEDC)
// PWM-uitgangspinnen
const int PWM_PIN_1 = 16;
const int PWM_PIN_2 = 17;
// ESP32 LEDC PWM-kanalen
const int PWM_CHANNEL_1 = 0;
const int PWM_CHANNEL_2 = 1;
void setup() {
// Initialiseer PWM met ESP32 LEDC
ledcSetup(PWM_CHANNEL_1, 5000, 8); // 5kHz, 8-bits resolutie
ledcSetup(PWM_CHANNEL_2, 5000, 8);
ledcAttachPin(PWM_PIN_1, PWM_CHANNEL_1);
ledcAttachPin(PWM_PIN_2, PWM_CHANNEL_2);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Map sliderwaarden (0-100) naar PWM-bereik (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Regel LED helderheid met ESP32 LEDC
ledcWrite(PWM_CHANNEL_1, pwm1);
ledcWrite(PWM_CHANNEL_2, pwm2);
Serial.println("LED1 Brightness: " + String(pwm1) +
", LED2 Brightness: " + String(pwm2));
});
}
Servo Positiecontrole
#include <ESP32Servo.h>
Servo servo1, servo2;
void setup() {
// Koppel servo's aan pinnen
servo1.attach(16);
servo2.attach(17);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Map sliderwaarden (0-100) naar servo hoeken (0-180°)
int angle1 = map(slider1, 0, 100, 0, 180);
int angle2 = map(slider2, 0, 100, 0, 180);
// Beweeg servo's naar berekende posities
servo1.write(angle1);
servo2.write(angle2);
Serial.println("Servo1: " + String(angle1) + "°, Servo2: " + String(angle2) + "°");
});
}
Motorsnelheidsregeling
// Motor driver pinnen
const int MOTOR1_PWM = 16; // Snelheidsregeling motor 1
const int MOTOR1_DIR1 = 18; // Richting pin 1 motor 1
const int MOTOR1_DIR2 = 19; // Richting pin 2 motor 1
const int MOTOR2_PWM = 17; // Snelheidsregeling motor 2
const int MOTOR2_DIR1 = 21; // Richting pin 1 motor 2
const int MOTOR2_DIR2 = 22; // Richting pin 2 motor 2
void setup() {
// Configureer motorpinnen
pinMode(MOTOR1_PWM, OUTPUT);
pinMode(MOTOR1_DIR1, OUTPUT);
pinMode(MOTOR1_DIR2, OUTPUT);
pinMode(MOTOR2_PWM, OUTPUT);
pinMode(MOTOR2_DIR1, OUTPUT);
pinMode(MOTOR2_DIR2, OUTPUT);
// Stel initiële motorrichtingen in (vooruit)
digitalWrite(MOTOR1_DIR1, HIGH);
digitalWrite(MOTOR1_DIR2, LOW);
digitalWrite(MOTOR2_DIR1, HIGH);
digitalWrite(MOTOR2_DIR2, LOW);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Map sliderwaarden (0-100) naar PWM-bereik (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Regel motorsnelheden
analogWrite(MOTOR1_PWM, pwm1);
analogWrite(MOTOR2_PWM, pwm2);
Serial.println("Motor1: " + String(slider1) + "%, " +
"Motor2: " + String(slider2) + "%");
});
}
RGB LED Kleurbesturing
// RGB LED pinnen
const int RED_PIN = 16;
const int GREEN_PIN = 17;
const int BLUE_PIN = 18;
void setup() {
pinMode(RED_PIN, OUTPUT);
pinMode(GREEN_PIN, OUTPUT);
pinMode(BLUE_PIN, OUTPUT);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Gebruik sliders voor RGB-componenten
// Slider 1 regelt rode intensiteit
// Slider 2 regelt blauwe intensiteit
// Groen wordt berekend op basis van beide sliders
int redValue = map(slider1, 0, 100, 0, 255);
int blueValue = map(slider2, 0, 100, 0, 255);
int greenValue = (redValue + blueValue) / 2;
analogWrite(RED_PIN, redValue);
analogWrite(GREEN_PIN, greenValue);
analogWrite(BLUE_PIN, blueValue);
Serial.println("RGB - R:" + String(redValue) +
" G:" + String(greenValue) +
" B:" + String(blueValue));
});
}
Geavanceerde Programmeertechnieken
Waarde Afvlakken
class SliderSmoother {
private:
int currentValue = 0;
int targetValue = 0;
unsigned long lastUpdate = 0;
const int SMOOTH_RATE = 2; // Verandering per update cyclus
public:
void setTarget(int target) {
targetValue = target;
}
int getCurrentValue() {
return currentValue;
}
bool update() {
if (millis() - lastUpdate > 10) { // Update elke 10ms
bool changed = false;
if (currentValue < targetValue) {
currentValue = min(currentValue + SMOOTH_RATE, targetValue);
changed = true;
} else if (currentValue > targetValue) {
currentValue = max(currentValue - SMOOTH_RATE, targetValue);
changed = true;
}
lastUpdate = millis();
return changed;
}
return false;
}
};
SliderSmoother smoother1, smoother2;
void setup() {
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Stel doelwaarden in voor vloeiende overgang
smoother1.setTarget(slider1);
smoother2.setTarget(slider2);
});
}
void loop() {
bluetoothServer.loop();
// Update gladde waarden
bool changed1 = smoother1.update();
bool changed2 = smoother2.update();
if (changed1 || changed2) {
// Map gladde waarden (0-100) naar PWM (0-255) en pas toe
analogWrite(16, map(smoother1.getCurrentValue(), 0, 100, 0, 255));
analogWrite(17, map(smoother2.getCurrentValue(), 0, 100, 0, 255));
}
}
Drempelgebaseerde Besturing
void setupThresholdControl() {
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Drempelgebaseerde besturing voor discrete outputs
const int LOW_THRESHOLD = 33;
const int MEDIUM_THRESHOLD = 66;
// Bestuur digitale uitgangen op basis van slider 1 drempels
if (slider1 < LOW_THRESHOLD) {
// Laag niveau: alle uitgangen uit
digitalWrite(18, LOW);
digitalWrite(19, LOW);
digitalWrite(21, LOW);
} else if (slider1 < MEDIUM_THRESHOLD) {
// Middel niveau: eerste uitgang aan
digitalWrite(18, HIGH);
digitalWrite(19, LOW);
digitalWrite(21, LOW);
} else {
// Hoog niveau: alle uitgangen aan
digitalWrite(18, HIGH);
digitalWrite(19, HIGH);
digitalWrite(21, HIGH);
}
// Gebruik slider 2 voor analoge PWM-besturing
analogWrite(16, map(slider2, 0, 100, 0, 255));
});
}
Preset Waardesysteem
// Vooraf gedefinieerde presetwaarden (bereik 0-100)
const int PRESETS[][2] = {
{0, 0}, // Preset 0: beide uit
{25, 50}, // Preset 1: laag/midden
{50, 50}, // Preset 2: beide midden
{100, 50}, // Preset 3: hoog/midden
{100, 100} // Preset 4: beide maximaal
};
void applyPreset(int presetNumber) {
if (presetNumber >= 0 && presetNumber < 5) {
currentSlider1 = PRESETS[presetNumber][0];
currentSlider2 = PRESETS[presetNumber][1];
// Update hardware
analogWrite(16, map(currentSlider1, 0, 100, 0, 255));
analogWrite(17, map(currentSlider2, 0, 100, 0, 255));
// Verstuur geüpdatete waarden naar de app
bluetoothSlider.send(currentSlider1, currentSlider2);
Serial.println("Applied preset " + String(presetNumber) +
": " + String(currentSlider1) + ", " + String(currentSlider2));
}
}
Hardware Integratie Voorbeelden
LED Strip Besturing
// Voor WS2812B of vergelijkbare adresseerbare LED-strips
// (vereist extra libraries zoals FastLED of Adafruit NeoPixel)
const int LED_STRIP_PIN = 16;
const int NUM_LEDS = 30;
void setupLEDStrip() {
// Initialiseer LED-strip (afhankelijk van gebruikte library)
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Slider 1 regelt helderheid (0-100 gemapt naar 0-255)
// Slider 2 regelt kleurtemperatuur of tint (0-100 gemapt naar 0-255)
uint8_t brightness = map(slider1, 0, 100, 0, 255);
uint8_t hue = map(slider2, 0, 100, 0, 255);
// Update LED-strip (voorbeeld met conceptuele functies)
// strip.setBrightness(brightness);
// strip.fill(CHSV(hue, 255, 255));
// strip.show();
Serial.println("LED Strip - Brightness: " + String(brightness) +
", Hue: " + String(hue));
});
}
Ventilator Snelheidsregeling
const int FAN1_PIN = 16;
const int FAN2_PIN = 17;
void setupFanControl() {
pinMode(FAN1_PIN, OUTPUT);
pinMode(FAN2_PIN, OUTPUT);
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
currentSlider1 = slider1;
currentSlider2 = slider2;
// Map sliderwaarden (0-100) naar PWM (0-255)
int pwm1 = map(slider1, 0, 100, 0, 255);
int pwm2 = map(slider2, 0, 100, 0, 255);
// Regel ventilatorsnelheden met minimumdrempel voor opstart
int fan1Speed = (pwm1 > 50) ? map(pwm1, 50, 255, 100, 255) : 0;
int fan2Speed = (pwm2 > 50) ? map(pwm2, 50, 255, 100, 255) : 0;
analogWrite(FAN1_PIN, fan1Speed);
analogWrite(FAN2_PIN, fan2Speed);
Serial.println("Fan1: " + String(slider1) + "%, " +
"Fan2: " + String(slider2) + "%");
});
}
BLE vs Classic Bluetooth - Welke te Kiezen?
| Feature | BLE (Esp32BLE_Slider) | Classic Bluetooth (Esp32Bluetooth_Slider) |
|---|---|---|
| iOS Ondersteuning | ? Ja | ? Nee |
| Android Ondersteuning | ? Ja | ? Ja |
| Vermogensverbruik | Laag | Hoger |
| Bereik | ~30-100m | ~10-100m |
| Data Snelheid | Lager | Hoger |
| Koppeling Nodig | Nee (auto-verbind) | Ja (handmatige koppeling) |
| Beste Voor | Battery-powered, cross-platform | Hoogdoorvoer, Android-only |
Problemen Oplossen
Veelvoorkomende Problemen
1. App kan apparaat niet vinden
- Zorg dat ESP32 is ingeschakeld en de sketch is geüpload
- Voor BLE: Zorg dat Bluetooth en Locatie op uw telefoon aanstaan
- Voor Classic Bluetooth: Koppel het apparaat eerst via Bluetooth-instellingen van de telefoon
- Controleer dat het juiste partitieschema is geselecteerd (Huge APP)
2. Sliders reageren niet
- Controleer de Bluetooth-verbinding in de app
- Bekijk de status in de Serial Monitor
- Probeer opnieuw verbinden
3. Waarden bereiken niet het hele bereik
- Controleer slider bereikconfiguratie: DIYables_BluetoothSlider(min, max, step)
- Controleer waardemapping in callback functie
- Bekijk de ontvangen waarden in de Serial Monitor
4. De verbinding valt vaak weg
- Kom dichter bij de ESP32 (verminder afstand)
- Voor BLE: Controleer op interferentie met andere BLE-apparaten
- Voor Classic Bluetooth: Zorg voor een stabiele voedingsspanning
- Bekijk disconnect/connect meldingen in Serial Monitor
5. PWM-uitgang werkt niet
- Controleer of de pinnen PWM ondersteunen op uw ESP32-model
- Gebruik voor ESP32: ledcSetup(), ledcAttachPin(), ledcWrite() voor hardware PWM
- Controleer hardwareverbindingen en belastingsvereisten
6. Sketch te groot / niet genoeg ruimte
- Kies in Arduino IDE via Tools > Partition Scheme de optie "Huge APP (3MB No OTA/1MB SPIFFS)" of "No OTA (Large APP)"
- Het standaard partitieschema geeft ~1.2MB voor code, wat niet genoeg is voor Bluetooth-libraries
- Deze instellingen geven ~3MB door de OTA-partitie op te offeren
Debug Tips
Voeg uitgebreide debugging toe:
void debugSliderValues(int slider1, int slider2) {
Serial.println("=== Slider Debug ===");
Serial.println("Slider 1: " + String(slider1) + "%");
Serial.println("Slider 2: " + String(slider2) + "%");
Serial.println("PWM 1: " + String(map(slider1, 0, 100, 0, 255)));
Serial.println("PWM 2: " + String(map(slider2, 0, 100, 0, 255)));
Serial.println("===================");
}
Projectideeën
Verlichtingsprojecten
- Kamerverlichting helderheidsregeling via Bluetooth
- RGB-kleurenmenginterface
- Snelheidsregeling voor LED-strip animaties
- Draadloze podiumverlichting
Motorbesturingsprojecten
- Bluetooth-gestuurde robotsnelheid
- Draadloze ventilatorsnelheidsregeling
- Pompsnelheidscontrole
- Transportband snelheid
Audioprojecten
- Draadloze volumeregeling
- Toon/equalizer besturing
- Geluidseffect intensiteit
Home Automation
- Draadloze klimaatregeling (verwarming/koeling intensiteit)
- Bluetooth jaloezie positionering
- Irrigatiesysteem debietregeling
Integratie met Andere Bluetooth Apps
Combineer met Bluetooth Joystick
Gebruik sliders voor snelheidslimieten en joystick voor richting:
// Globale snelheidslimiet van sliders
int maxSpeed = 100;
// In Bluetooth Slider callback
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
maxSpeed = slider1; // Gebruik slider 1 als globale snelheidslimiet
});
// In Bluetooth Joystick callback
bluetoothJoystick.onJoystickValue([](int x, int y) {
// Schaal joystick waarden met slidergeregelde snelheidslimiet
int scaledX = map(x, -100, 100, -maxSpeed, maxSpeed);
int scaledY = map(y, -100, 100, -maxSpeed, maxSpeed);
controlRobot(scaledX, scaledY);
});
Combineer met Bluetooth Digitale Pinnen
Gebruik sliders voor PWM en digitale pinnen voor aan/uit:
bluetoothSlider.onSliderValue([](int slider1, int slider2) {
// Pas PWM alleen toe als corresponderende digitale pin aan staat
if (digitalRead(18) == HIGH) {
analogWrite(16, map(slider1, 0, 100, 0, 255));
} else {
analogWrite(16, 0);
}
if (digitalRead(19) == HIGH) {
analogWrite(17, map(slider2, 0, 100, 0, 255));
} else {
analogWrite(17, 0);
}
});
Volgende Stappen
Na het beheersen van het Bluetooth Slider voorbeeld, probeer:
- Bluetooth Joystick - Voor 2D richtingsbesturing
- Bluetooth Digital Pins - Voor discrete aan/uit besturing
- Bluetooth Monitor - Voor debugging van sliderwaarden
- Meerdere Bluetooth Apps - Combineren van sliders met andere besturingen
Ondersteuning
Voor extra hulp:
- Raadpleeg de API Reference documentatie
- Bezoek DIYables tutorials
- Arduino community forums
Gerelateerde Tutorials
📱 Aanbevolen apps
English for KidsSpelenderwijs Engels leren voor jonge kinderen.Ontdek het opGoogle PlayBeschikbaar in deApp Store
Bubble NoteZelfverwijderende notities – schrijf ze als berichten.Ontdek het opGoogle PlayBeschikbaar in deApp Store
Didn't BuyVersla impulsaankopen en bespaar meer.Ontdek het opGoogle PlayBeschikbaar in deApp Store
Knowledge PathOefentoetsen om alles te leren.Ontdek het opGoogle PlayBeschikbaar in deApp Store