ESP32 Tutorial 38/55 - RGB-LED vanaf je mobiele telefoon bedienen | SunFounder's ESP32 IoT-leerkit

ESP32 Tutorial 38/55 - RGB-LED vanaf je mobiele telefoon bedienen | SunFounder's ESP32 IoT-leerkit

In deze tutorial verkennen we hoe je een RGB-LED kunt aansturen met behulp van een ESP32-module uit de SunFounder ESP32-leerkit. Door opdrachten vanaf je mobiele apparaat te sturen, kun je de LED-kleur veranderen of deze volledig uitschakelen. Dit project maakt gebruik van de mogelijkheden van de ESP32, waarbij gebruik wordt gemaakt van de ingebouwde Wi-Fi- en Bluetooth-functies voor naadloze connectiviteit en bediening.

De RGB-LED bestaat uit drie afzonderlijke LED's: rood, groen en blauw, die kunnen worden gemengd om verschillende kleuren te creëren. In dit project leer je hoe je de RGB-LED correct bedraadt en de ESP32 programmeert om te reageren op Bluetooth-opdrachten. De tutorial begeleidt je ook door de benodigde codecomponenten om deze functionaliteit te bereiken (in video op 02:15).

Hardware uitgelegd

De primaire componenten voor dit project zijn de ESP32-microcontroller en de RGB-LED. De ESP32 is een krachtige module met ingebouwde Wi-Fi en Bluetooth, waardoor deze ideaal is voor IoT-toepassingen. In dit project fungeert het als een server om opdrachten van een mobiel apparaat te ontvangen en de RGB-LED dienovereenkomstig aan te sturen.

De RGB-LED heeft vier pinnen: één gemeenschappelijke pin (ofwel anode of kathode) en drie pinnen voor de afzonderlijke kleuren. De gemeenschappelijke pin wordt verbonden met ofwel de stroombron of aarde, terwijl de andere drie pinnen via weerstanden worden verbonden met de GPIO-pinnen van de ESP32 om de stroom te beperken en de LED's te beschermen. Deze opstelling maakt nauwkeurige regeling van de helderheid van elke kleur mogelijk, waardoor een breed scala aan kleuren ontstaat.

Datasheet-details

• Zorg voor de juiste weerstandswaarden (meestal 220 Ohm) om de stroom door elk LED-kanaal te beperken.
• Controleer de configuratie van de gemeenschappelijke pin (anode of kathode) vóór het bedraden.
• Gebruik PWM voor dimmen en kleurmenging door het signaal naar elke LED aan te passen.
• Wees voorzichtig met bedrading om kortsluiting te voorkomen; sluit één pin tegelijk aan.
• Test elke kleur afzonderlijk na de opstelling om de juiste bedrading te bevestigen.

Bedradingsinstructies

Om de RGB-LED op de ESP32 aan te sluiten, begin je met het plaatsen van de RGB-LED op een breadboard. De langere pin is de gemeenschappelijke pin, die je verbindt met ofwel de positieve spanning (voor gemeenschappelijke anode) of aarde (voor gemeenschappelijke kathode). Als je een gemeenschappelijke anode gebruikt, verbind je de lange pin met de 3,3V-pin op de ESP32. Voor gemeenschappelijke kathode verbind je deze met de GND-pin.

Neem vervolgens drie 220 Ohm-weerstanden en verbind één uiteinde van elke weerstand met de overeenkomstige RGB-pinnen van de LED. Verbind de andere uiteinden van de weerstanden met de GPIO-pinnen van de ESP32: verbind de rode pin van de LED met GPIO 27, de groene pin met GPIO 26 en de blauwe pin met GPIO 25. Zorg er ten slotte voor dat de gemeenschappelijke pin op de juiste manier is aangesloten op basis van je configuratie (anode of kathode).

Codevoorbeelden & uitleg

De code voor dit project begint met het definiëren van de pinnen die zijn verbonden met de RGB-LED. Het volgende fragment laat zien hoe de pinnen worden gedeclareerd:

const int redPin = 27;
const int greenPin = 26;
const int bluePin = 25;

Hier worden redPin, greenPin en bluePin toegewezen aan specifieke GPIO-nummers op de ESP32 voor elk kleurkanaal van de RGB-LED.

In de setup-functie wordt Bluetooth geïnitialiseerd en worden de PWM-instellingen toegepast. Dit fragment demonstreert deze initialisatie:

void setup() {
  Serial.begin(115200);      // Initialiseer de seriële poort
  setupBLE();                // Initialiseer de Bluetooth BLE

  ledcAttach(redPin, freq, resolution);
  ledcAttach(greenPin, freq, resolution);
  ledcAttach(bluePin, freq, resolution);
}

Deze code initialiseert de seriële communicatie en stelt de Bluetooth-functionaliteit in, terwijl de RGB-LED-pinnen worden gekoppeld aan PWM-kanalen voor aansturing.

Ten slotte controleert de loop-functie op ontvangen Bluetooth-berichten en past de LED-kleur dienovereenkomstig aan:

if (value == "red") {
  setColor(255, 0, 0); // Rood
  Serial.println("red");
}

In dit gedeelte wordt, als de ontvangen waarde "red" is, de LED ingesteld op volledige rode helderheid met behulp van de setColor-functie.

Voor een volledig begrip van de code wordt aanbevolen om de video-tutorial te bekijken, waar de volledige code onder het artikel wordt geladen.

Demonstratie / Wat te verwachten

Zodra alles is bedraad en de code is geüpload, zou je de RGB-LED vanaf je mobiele apparaat via Bluetooth moeten kunnen aansturen. Door opdrachten zoals "red", "green", "blue", enz. te sturen, zie je de LED dienovereenkomstig van kleur veranderen. Als je "LED_off" stuurt, wordt de RGB-LED uitgeschakeld. Zorg ervoor dat je de seriële monitor controleert op eventuele foutopsporingsberichten om te bevestigen dat opdrachten correct worden ontvangen (in video op 10:45).

Video-tijdstempels

• 00:00 Start
• 1:59 Wat is RGB LED?
• 6:01 RGB-kleur uitgelegd
• 10:01 Documentatiepagina
• 11:19 Bedrading uitgelegd
• 13:34 ESP32-board en COM-poort selecteren in Arduino IDE
• 15:15 Arduino-code
• 18:02 Demonstratie van het bedienen van RGB LED met je telefoon

Afbeeldingen

ESP32_rgb_pin

ESP32_RGB_led_wires

ES32-38_RGB_LED-wiring

ESP32_rgb_pin

ESP32_RGB_led_wires

ES32-38_RGB_LED-wiring

#include "BLEDevice.h"
#include "BLEServer.h"
#include "BLEUtils.h"
#include "BLE2902.h"

// Define RGB LED pins
const int redPin = 27;
const int greenPin = 26;
const int bluePin = 25;

// Define PWM frequency and resolution
const int freq = 5000;
const int resolution = 8;

// Define the Bluetooth device name
const char *bleName = "ESP32_Bluetooth";

// Define the received text and the time of the last message
String receivedText = "";
unsigned long lastMessageTime = 0;

// Define the UUIDs of the service and characteristics
#define SERVICE_UUID "8785d8b3-9d23-473b-aee5-3fabe2ba9583"
#define CHARACTERISTIC_UUID_RX "b2bcd13b-aab6-4660-92ae-40abf6941fce"
#define CHARACTERISTIC_UUID_TX "4219d86a-d701-4fd2-bd84-04db50f70fe2"

// Define the Bluetooth characteristic
BLECharacteristic *pCharacteristic;

void setup() {
  Serial.begin(115200);      // Initialize the serial port
  setupBLE();                // Initialize the Bluetooth BLE

  ledcAttach(redPin, freq, resolution);
  ledcAttach(greenPin, freq, resolution);
  ledcAttach(bluePin, freq, resolution);
}

void loop() {
  // When the received text is not empty and the time since the last message is over 1 second
  // Send a notification and print the received text
  if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("Received message: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
  }

  // Read data from the serial port and send it to BLE characteristic
  if (Serial.available() > 0) {
    String str = Serial.readStringUntil('\n');
    const char *newValue = str.c_str();
    pCharacteristic->setValue(newValue);
    pCharacteristic->notify();
  }
}

// Define the BLE server callbacks
class MyServerCallbacks : public BLEServerCallbacks {
  // Print the connection message when a client is connected
  void onConnect(BLEServer *pServer) {
    Serial.println("Connected");
  }
  // Print the disconnection message when a client is disconnected
  void onDisconnect(BLEServer *pServer) {
    Serial.println("Disconnected");
  }
};

// Define the BLE characteristic callbacks
class MyCharacteristicCallbacks : public BLECharacteristicCallbacks {
  void onWrite(BLECharacteristic *pCharacteristic) {
    std::string value = std::string(pCharacteristic->getValue().c_str());
    if (value == "led_off") {
      setColor(0, 0, 0); // turn the RGB LED off
      Serial.println("RGB LED turned off");
    } else if (value == "red") {
      setColor(255, 0, 0); // Red
      Serial.println("red");
    }
    else if (value == "green") {
      setColor(0, 255, 0); // green
      Serial.println("green");
    }
    else if (value == "blue") {
      setColor(0, 0, 255); // blue
      Serial.println("blue");
    }
    else if (value == "yellow") {
      setColor(255, 150, 0); // yellow
      Serial.println("yellow");
    }
    else if (value == "purple") {
      setColor(80, 0, 80); // purple
      Serial.println("purple");
    }
  }
};

// Initialize the Bluetooth BLE
void setupBLE() {
  BLEDevice::init(bleName);                        // Initialize the BLE device
  BLEServer *pServer = BLEDevice::createServer();  // Create the BLE server
  // Print the error message if the BLE server creation fails
  if (pServer == nullptr) {
    Serial.println("Error creating BLE server");
    return;
  }
  pServer->setCallbacks(new MyServerCallbacks());  // Set the BLE server callbacks

  // Create the BLE service
  BLEService *pService = pServer->createService(SERVICE_UUID);
  // Print the error message if the BLE service creation fails
  if (pService == nullptr) {
    Serial.println("Error creating BLE service");
    return;
  }
  // Create the BLE characteristic for sending notifications
  pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
  pCharacteristic->addDescriptor(new BLE2902());  // Add the descriptor
  // Create the BLE characteristic for receiving data
  BLECharacteristic *pCharacteristicRX = pService->createCharacteristic(CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
  pCharacteristicRX->setCallbacks(new MyCharacteristicCallbacks());  // Set the BLE characteristic callbacks
  pService->start();                                                 // Start the BLE service
  pServer->getAdvertising()->start();                                // Start advertising
  Serial.println("Waiting for a client connection...");              // Wait for a client connection
}

void setColor(int red, int green, int blue) {
  // For common-anode RGB LEDs, use 255 minus the color value
  ledcWrite(redPin, red);
  ledcWrite(greenPin, green);
  ledcWrite(bluePin, blue);
}