ESP32 Tutorijal 38/55 - Upravljanje RGB LED diodom sa vašeg mobilnog telefona | SunFounder's ESP32 IoT Learning kit

ESP32 Tutorijal 38/55 - Upravljanje RGB LED diodom sa vašeg mobilnog telefona | SunFounder's ESP32 IoT Learning kit

U ovom tutorijalu ćemo istražiti kako kontrolisati RGB LED koristeći ESP32 modul iz SunFounder ESP32 edukativnog kompleta. Slanjem komandi sa vašeg mobilnog uređaja, možete promijeniti boju LED-a ili ga potpuno ugasiti. Ovaj projekat koristi mogućnosti ESP32-a, iskorištavajući ugrađene Wi-Fi i Bluetooth funkcije za besprijekornu povezanost i kontrolu.

RGB LED se sastoji od tri pojedinačne LED diode: crvene, zelene i plave, koje se mogu miješati kako bi se stvorile različite boje. U ovom projektu naučit ćete kako pravilno povezati RGB LED i programirati ESP32 da reaguje na Bluetooth komande. Tutorijal će vas također provesti kroz potrebne dijelove koda za postizanje ove funkcionalnosti (u videu na 02:15).

Objašnjenje hardvera

Primarne komponente za ovaj projekat uključuju ESP32 mikrokontroler i RGB LED. ESP32 je moćan modul sa ugrađenim Wi-Fi i Bluetooth funkcijama, što ga čini idealnim za IoT aplikacije. U ovom projektu, on će djelovati kao server za primanje komandi sa mobilnog uređaja i kontrolisanje RGB LED-a u skladu s tim.

RGB LED ima četiri pina: jedan zajednički pin (bilo anoda ili katoda) i tri pina za pojedinačne boje. Zajednički pin se povezuje ili na izvor napajanja ili na masu, dok se ostala tri pina povezuju na GPIO pinove ESP32-a preko otpornika kako bi se ograničila struja i zaštitile LED diode. Ova postavka omogućava preciznu kontrolu svjetline svake boje, stvarajući širok raspon boja.

Detalji iz tehničke specifikacije

• Osigurajte odgovarajuće vrijednosti otpornika (obično 220 Ohma) kako biste ograničili struju kroz svaki LED kanal.
• Provjerite konfiguraciju zajedničkog pina (anoda ili katoda) prije povezivanja.
• Koristite PWM za zatamnjivanje i miješanje boja podešavanjem signala poslanog svakoj LED diodi.
• Budite oprezni s povezivanjem kako biste izbjegli kratke spojeve; povežite jedan pin po jedan.
• Testirajte svaku boju pojedinačno nakon postavljanja kako biste potvrdili ispravno povezivanje.

Upute za povezivanje

Da biste povezali RGB LED na ESP32, počnite postavljanjem RGB LED-a na breadboard. Duži pin je zajednički pin, koji ćete povezati ili na pozitivni napon (za zajedničku anodu) ili na masu (za zajedničku katodu). Ako koristite zajedničku anodu, povežite dugi pin na 3.3V pin na ESP32-u. Za zajedničku katodu, povežite ga na GND pin.

Zatim uzmite tri otpornika od 220 Ohma i povežite jedan kraj svakog otpornika na odgovarajuće RGB pinove LED-a. Povežite druge krajeve otpornika na GPIO pinove ESP32-a: povežite crveni pin LED-a na GPIO 27, zeleni pin na GPIO 26, a plavi pin na GPIO 25. Na kraju, osigurajte da je zajednički pin pravilno povezan prema vašoj konfiguraciji (anoda ili katoda).

Primjeri koda i objašnjenje

Kod za ovaj projekat počinje definisanjem pinova povezanih na RGB LED. Sljedeći izvod pokazuje kako su pinovi deklarirani:

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

Ovdje su redPin, greenPin i bluePin dodijeljeni određenim GPIO brojevima na ESP32-u za svaki kanal boje RGB LED-a.

U setup funkciji, Bluetooth se inicijalizira i primjenjuju se PWM postavke. Ovaj izvod demonstrira ovu inicijalizaciju:

void setup() {
  Serial.begin(115200);      // Inicijaliziraj serijski port
  setupBLE();                // Inicijaliziraj Bluetooth BLE

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

Ovaj kod inicijalizira serijsku komunikaciju i postavlja Bluetooth funkcionalnost dok prikačuje RGB LED pinove na PWM kanale za kontrolu.

Na kraju, loop funkcija provjerava primljene Bluetooth poruke i prilagođava boju LED-a u skladu s tim:

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

U ovom dijelu, ako je primljena vrijednost "red", LED će biti postavljen na punu crvenu svjetlinu koristeći setColor funkciju.

Za potpuno razumijevanje koda, preporučuje se gledanje video tutorijala gdje je kompletan kod učitan ispod članka.

Demonstracija / Šta očekivati

Kada je sve povezano i kod je uploadan, trebali biste moći kontrolisati RGB LED sa svog mobilnog uređaja putem Bluetootha. Slanjem komandi poput "red", "green", "blue" itd., vidjet ćete kako LED mijenja boje u skladu s tim. Ako pošaljete "LED_off", RGB LED će se ugasiti. Provjerite serijski monitor za bilo kakve poruke za otklanjanje grešaka kako biste potvrdili da se komande pravilno primaju (u videu na 10:45).

Vremenske oznake videa

• 00:00 Početak
• 1:59 Šta je RGB LED?
• 6:01 RGB boja objašnjena
• 10:01 Stranica dokumentacije
• 11:19 Povezivanje objašnjeno
• 13:34 Odabir ESP32 ploče i COM porta u Arduino IDE-u
• 15:15 Arduino kod
• 18:02 Demonstracija upravljanja RGB LED diodom pomoću vašeg telefona

Slike

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