Mafunzo ya ESP32 38/55 - Kudhibiti LED ya RGB kutoka kwenye simu yako ya mkononi | Kifurushi cha Kujifunza cha IoT cha SunFounder cha ESP32

Mafunzo ya ESP32 38/55 - Kudhibiti LED ya RGB kutoka kwenye simu yako ya mkononi | Kifurushi cha Kujifunza cha IoT cha SunFounder cha ESP32

Katika mafunzo haya, tutachunguza jinsi ya kudhibiti LED ya RGB kwa kutumia moduli ya ESP32 kutoka kwenye kit cha kujifunza cha SunFounder ESP32. Kwa kutuma amri kutoka kwenye kifaa chako cha mkononi, unaweza kubadilisha rangi ya LED au kuizima kabisa. Mradi huu unatumia uwezo wa ESP32, kwa kutumia vipengele vilivyojengewa ndani vya Wi-Fi na Bluetooth kwa muunganisho na udhibiti usio na mshono.

LED ya RGB inajumuisha LED tatu tofauti: nyekundu, kijani, na bluu, ambazo zinaweza kuchanganywa kuunda rangi mbalimbali. Katika mradi huu, utajifunza jinsi ya kuunganisha LED ya RGB kwa usahihi na kupanga ESP32 kujibu amri za Bluetooth. Mafunzo pia yatakuongoza kupitia vipengele muhimu vya msimbo ili kufikia utendaji huu (katika video saa 02:15).

Vifaa Vimeelezwa

Vipengele vikuu vya mradi huu vinajumuisha microcontroller ya ESP32 na LED ya RGB. ESP32 ni moduli yenye nguvu iliyo na Wi-Fi na Bluetooth zilizojengewa ndani, na kuifanya kuwa bora kwa programu za IoT. Katika mradi huu, itafanya kazi kama seva kupokea amri kutoka kwenye kifaa cha mkononi na kudhibiti LED ya RGB ipasavyo.

LED ya RGB ina pini nne: pini moja ya kawaida (ama anode au cathode) na pini tatu za rangi binafsi. Pini ya kawaida inaunganishwa kwenye chanzo cha nguvu au ardhi, wakati pini nyingine tatu zinaunganishwa kwenye pini za GPIO za ESP32 kupitia resistors ili kupunguza mkondo na kulinda LED. Mpangilio huu unaruhusu udhibiti sahihi wa mwangaza wa kila rangi, kuunda anuwai kubwa ya rangi.

Maelezo ya Datasheet

• Hakikisha maadili sahihi ya resistor (kawaida 220 Ohm) ili kupunguza mkondo kupitia kila chaneli ya LED.
• Angalia usanidi wa pini ya kawaida (anode au cathode) kabla ya kuunganisha.
• Tumia PWM kwa kupunguza mwangaza na kuchanganya rangi kwa kurekebisha ishara inayotumwa kwa kila LED.
• Kuwa makini na wiring ili kuepuka mzunguko mfupi; unganisha pini moja kwa wakati.
• Jaribu kila rangi kibinafsi baada ya usanidi ili kuthibitisha wiring sahihi.

Maagizo ya Wiring

Ili kuunganisha LED ya RGB kwenye ESP32, anza kwa kuweka LED ya RGB kwenye breadboard. Pini ndefu ni pini ya kawaida, ambayo utaiunganisha kwenye voltage chanya (kwa anode ya kawaida) au ardhi (kwa cathode ya kawaida). Ikiwa unatumia anode ya kawaida, unganisha pini ndefu kwenye pini ya 3.3V kwenye ESP32. Kwa cathode ya kawaida, unganisha kwenye pini ya GND.

Ifuatayo, chukua resistors tatu za 220 Ohm na unganisha mwisho mmoja wa kila resistor kwenye pini zinazolingana za RGB za LED. Unganisha ncha nyingine za resistors kwenye pini za GPIO za ESP32: unganisha pini nyekundu ya LED kwenye GPIO 27, pini ya kijani kwenye GPIO 26, na pini ya bluu kwenye GPIO 25. Hatimaye, hakikisha kwamba pini ya kawaida imeunganishwa ipasavyo kulingana na usanidi wako (anode au cathode).

Mifano ya Msimbo & Maelezo

Msimbo wa mradi huu huanza kwa kufafanua pini zilizounganishwa kwenye LED ya RGB. Sehemu ifuatayo inaonyesha jinsi pini zinavyotangazwa:

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

Hapa, redPin, greenPin, na bluePin zimepewa nambari maalum za GPIO kwenye ESP32 kwa kila chaneli ya rangi ya LED ya RGB.

Katika kazi ya setup, Bluetooth inaanzishwa, na mipangilio ya PWM inatumika. Sehemu hii inaonyesha uanzishaji huu:

void setup() {
  Serial.begin(115200);      // Anzisha mlango wa serial
  setupBLE();                // Anzisha Bluetooth BLE

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

Msimbo huu unaanzisha mawasiliano ya serial na kuanzisha utendaji wa Bluetooth huku ukiunganisha pini za LED ya RGB kwenye chaneli za PWM kwa udhibiti.

Hatimaye, kazi ya loop inaangalia ujumbe wa Bluetooth uliopokelewa na kurekebisha rangi ya LED ipasavyo:

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

Katika sehemu hii, ikiwa thamani iliyopokelewa ni "red", LED itawekwa kwenye mwangaza kamili wa nyekundu kwa kutumia kazi ya setColor.

Kwa uelewa kamili wa msimbo, inapendekezwa kutazama mafunzo ya video ambapo msimbo kamili umepakiwa chini ya makala.

Maonyesho / Nini cha Kutarajia

Mara tu kila kitu kimeunganishwa na msimbo umepakiwa, utaweza kudhibiti LED ya RGB kutoka kwenye kifaa chako cha mkononi kupitia Bluetooth. Kwa kutuma amri kama "red", "green", "blue", n.k., utaona LED ikibadilisha rangi ipasavyo. Ukituma "LED_off", LED ya RGB itazima. Hakikisha unaangalia serial monitor kwa ujumbe wowote wa utatuzi ili kuthibitisha kwamba amri zinapokelewa kwa usahihi (katika video saa 10:45).

Vidokezo vya Muda vya Video

• 00:00 Anza
• 1:59 RGB LED ni nini?
• 6:01 Rangi ya RGB imeelezwa
• 10:01 Ukurasa wa nyaraka
• 11:19 Uunganisho wa waya umeelezwa
• 13:34 Kuchagua bodi ya ESP32 na mlango wa COM katika Arduino IDE
• 15:15 Msimbo wa Arduino
• 18:02 Maonyesho ya kudhibiti RGB LED kwa kutumia simu yako

Bilder

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