ESP32 Tutoriaal 38/55 - Beheer van RGB-LED vanaf jou selfoon | SunFounder se ESP32 IoT-leerkit

ESP32 Tutoriaal 38/55 - Beheer van RGB-LED vanaf jou selfoon | SunFounder se ESP32 IoT-leerkit

In hierdie tutoriaal gaan ons ondersoek hoe om 'n RGB-LED te beheer met behulp van 'n ESP32-module uit die SunFounder ESP32-leerkit. Deur opdragte vanaf jou mobiele toestel te stuur, kan jy die LED-kleur verander of dit heeltemal afskakel. Hierdie projek benut die vermoëns van die ESP32, en gebruik ingeboude Wi-Fi- en Bluetooth-kenmerke vir naatlose konnektiwiteit en beheer.

Die RGB-LED bestaan uit drie individuele LED's: rooi, groen en blou, wat gemeng kan word om verskeie kleure te skep. In hierdie projek sal jy leer hoe om die RGB-LED korrek te bedraad en die ESP32 te programmeer om op Bluetooth-opdragte te reageer. Die tutoriaal sal jou ook deur die nodige kodekomponente lei om hierdie funksionaliteit te bereik (in video by 02:15).

Hardeware Verduidelik

Die primêre komponente vir hierdie projek sluit die ESP32-mikrobeheerder en die RGB-LED in. Die ESP32 is 'n kragtige module met ingeboude Wi-Fi en Bluetooth, wat dit ideaal maak vir IoT-toepassings. In hierdie projek sal dit as 'n bediener optree om opdragte van 'n mobiele toestel te ontvang en die RGB-LED dienooreenkomstig te beheer.

Die RGB-LED het vier penne: een gemeenskaplike pen (óf anode óf katode) en drie penne vir die individuele kleure. Die gemeenskaplike pen verbind aan óf die kragbron óf grond, terwyl die ander drie penne aan die ESP32 se GPIO-penne verbind deur resistors om die stroom te beperk en die LED's te beskerm. Hierdie opstelling maak voorsiening vir presiese beheer van elke kleur se helderheid, wat 'n wye reeks kleure skep.

Datablad Besonderhede

• Verseker behoorlike resistorwaardes (tipies 220 Ohm) om stroom deur elke LED-kanaal te beperk.
• Kontroleer die gemeenskaplike penkonfigurasie (anode of katode) voor bedrading.
• Gebruik PWM vir verdimming en kleurmenging deur die sein na elke LED aan te pas.
• Wees versigtig met bedrading om kortsluitings te vermy; verbind een pen op 'n slag.
• Toets elke kleur individueel na opstelling om korrekte bedrading te bevestig.

Bedradingsinstruksies

Om die RGB-LED aan die ESP32 te bedraad, begin deur die RGB-LED op 'n broodbord te plaas. Die langer pen is die gemeenskaplike pen, wat jy aan óf die positiewe spanning (vir gemeenskaplike anode) óf grond (vir gemeenskaplike katode) sal verbind. As jy gemeenskaplike anode gebruik, verbind die lang pen aan die 3.3V-pen op die ESP32. Vir gemeenskaplike katode, verbind dit aan die GND-pen.

Neem dan drie 220 Ohm resistors en verbind een punt van elke resistor aan die ooreenstemmende RGB-penne van die LED. Verbind die ander punte van die resistors aan die ESP32 GPIO-penne: verbind die rooi pen van die LED aan GPIO 27, die groen pen aan GPIO 26, en die blou pen aan GPIO 25. Maak laastens seker dat die gemeenskaplike pen toepaslik verbind is gebaseer op jou konfigurasie (anode of katode).

Kode Voorbeelde & Deurloop

Die kode vir hierdie projek begin deur die penne wat aan die RGB-LED gekoppel is, te definieer. Die volgende uittreksel wys hoe die penne verklaar word:

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

Hier word redPin, greenPin en bluePin aan spesifieke GPIO-nommers op die ESP32 toegewys vir elke kleurkanaal van die RGB-LED.

In die opstellingsfunksie word die Bluetooth geïnisialiseer en die PWM-instellings toegepas. Hierdie uittreksel demonstreer hierdie inisialisering:

void setup() {
  Serial.begin(115200);      // Initialiseer die seriepoort
  setupBLE();                // Initialiseer die Bluetooth BLE

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

Hierdie kode initialiseer die seriekommunikasie en stel die Bluetooth-funksionaliteit op terwyl die RGB-LED-penne aan PWM-kanale vir beheer gekoppel word.

Laastens kontroleer die lusfunksie vir ontvangde Bluetooth-boodskappe en pas die LED-kleur dienooreenkomstig aan:

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

In hierdie afdeling, as die ontvangde waarde "red" is, sal die LED op volle rooi helderheid gestel word deur die setColor-funksie.

Vir 'n volledige begrip van die kode word dit aanbeveel om die video-tutoriaal te kyk waar die volledige kode onder die artikel gelaai word.

Demonstrasie / Wat om te VerwAg

Sodra alles bedraad is en die kode opgelaai is, behoort jy die RGB-LED vanaf jou mobiele toestel via Bluetooth te kan beheer. Deur opdragte soos "red", "green", "blue", ens. te stuur, sal jy sien hoe die LED-kleure dienooreenkomstig verander. As jy "LED_off" stuur, sal die RGB-LED afskakel. Maak seker dat jy die serie-monitor nagaan vir enige ontfoutingsboodskappe om te bevestig dat opdragte korrek ontvang word (in video by 10:45).

Video Tydstempels

• 00:00 Begin
• 1:59 Wat is RGB LED?
• 6:01 RGB-kleur verduidelik
• 10:01 Dokumentasiebladsy
• 11:19 Bedrading verduidelik
• 13:34 Kies ESP32-bord en COM-poort in Arduino IDE
• 15:15 Arduino-kode
• 18:02 Demonstrasie van die beheer van RGB LED met jou foon

Beelde

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);
}