Tutorial ESP32 38/55 - Controlarea LED-ului RGB de pe telefonul tău mobil | Kitul de învățare IoT ESP32 de la SunFounder

Tutorial ESP32 38/55 - Controlarea LED-ului RGB de pe telefonul tău mobil | Kitul de învățare IoT ESP32 de la SunFounder

În acest tutorial, vom explora cum să controlăm un LED RGB folosind un modul ESP32 din kitul de învățare ESP32 SunFounder. Trimițând comenzi de pe dispozitivul tău mobil, poți schimba culoarea LED-ului sau îl poți opri complet. Acest proiect valorifică capacitățile ESP32, utilizând funcțiile integrate Wi-Fi și Bluetooth pentru conectivitate și control fără întreruperi.

LED-ul RGB este format din trei LED-uri individuale: roșu, verde și albastru, care pot fi amestecate pentru a crea diverse culori. În acest proiect, vei învăța cum să conectezi corect LED-ul RGB și să programezi ESP32 pentru a răspunde la comenzile Bluetooth. Tutorialul te va ghida, de asemenea, prin componentele de cod necesare pentru a realiza această funcționalitate (în video la 02:15).

Hardware Explicat

Componentele principale pentru acest proiect includ microcontrolerul ESP32 și LED-ul RGB. ESP32 este un modul puternic cu Wi-Fi și Bluetooth integrate, fiind ideal pentru aplicații IoT. În acest proiect, va acționa ca un server pentru a primi comenzi de pe un dispozitiv mobil și a controla LED-ul RGB în consecință.

LED-ul RGB are patru pini: un pin comun (fie anod, fie catod) și trei pini pentru culorile individuale. Pinul comun se conectează fie la sursa de alimentare, fie la masă, în timp ce ceilalți trei pini se conectează la pinii GPIO ai ESP32 prin rezistențe pentru a limita curentul și a proteja LED-urile. Această configurație permite controlul precis al luminozității fiecărei culori, creând o gamă largă de culori.

Detalii din Fișa Tehnică

• Asigură-te că folosești valori corecte ale rezistențelor (de obicei 220 Ohm) pentru a limita curentul prin fiecare canal LED.
• Verifică configurația pinului comun (anod sau catod) înainte de cablare.
• Folosește PWM pentru diminuare și amestecarea culorilor prin ajustarea semnalului trimis fiecărui LED.
• Fii atent la cablare pentru a evita scurtcircuitele; conectează un pin la un moment dat.
• Testează fiecare culoare individual după configurare pentru a confirma cablarea corectă.

Instrucțiuni de Cablare

Pentru a conecta LED-ul RGB la ESP32, începe prin a plasa LED-ul RGB pe o placă de test. Pinul mai lung este pinul comun, pe care îl vei conecta fie la tensiunea pozitivă (pentru anod comun), fie la masă (pentru catod comun). Dacă folosești anod comun, conectează pinul lung la pinul de 3,3V de pe ESP32. Pentru catod comun, conectează-l la pinul GND.

Apoi, ia trei rezistențe de 220 Ohm și conectează un capăt al fiecărei rezistențe la pinii RGB corespunzători ai LED-ului. Conectează celelalte capete ale rezistențelor la pinii GPIO ai ESP32: conectează pinul roșu al LED-ului la GPIO 27, pinul verde la GPIO 26 și pinul albastru la GPIO 25. În final, asigură-te că pinul comun este conectat corespunzător în funcție de configurația ta (anod sau catod).

Exemple de Cod & Explicații

Codul pentru acest proiect începe prin definirea pinilor conectați la LED-ul RGB. Următorul fragment arată cum sunt declarați pinii:

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

Aici, redPin, greenPin și bluePin sunt atribuite unor numere GPIO specifice de pe ESP32 pentru fiecare canal de culoare al LED-ului RGB.

În funcția de configurare, Bluetooth-ul este inițializat, iar setările PWM sunt aplicate. Acest fragment demonstrează această inițializare:

void setup() {
  Serial.begin(115200);      // Inițializează portul serial
  setupBLE();                // Inițializează Bluetooth BLE

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

Acest cod inițializează comunicarea serială și configurează funcționalitatea Bluetooth, atașând în același timp pinii LED-ului RGB la canalele PWM pentru control.

În final, funcția de buclă verifică mesajele Bluetooth primite și ajustează culoarea LED-ului în consecință:

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

În această secțiune, dacă valoarea primită este "red", LED-ul va fi setat la luminozitate roșie completă folosind funcția setColor.

Pentru o înțelegere completă a codului, este recomandat să urmărești tutorialul video unde codul complet este încărcat sub articol.

Demonstrație / Ce să Te Aștepți

Odată ce totul este cablat și codul este încărcat, ar trebui să poți controla LED-ul RGB de pe dispozitivul tău mobil prin Bluetooth. Trimițând comenzi precum "red", "green", "blue" etc., vei vedea LED-ul schimbându-și culorile în consecință. Dacă trimiți "LED_off", LED-ul RGB se va opri. Asigură-te că verifici monitorul serial pentru orice mesaje de depanare pentru a confirma că comenzile sunt primite corect (în video la 10:45).

Marcaje Temporale Video

• 00:00 Start
• 1:59 Ce este LED-ul RGB?
• 6:01 Culoarea RGB explicată
• 10:01 Pagina de documentație
• 11:19 Conexiunile explicate
• 13:34 Selectarea plăcii ESP32 și a portului COM în Arduino IDE
• 15:15 Codul Arduino
• 18:02 Demonstrație de control al LED-ului RGB folosind telefonul tău

Imagini

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