Tutorial ESP32 38/55 - Xakamaynta LED RGB ee taleefankaaga gacanta | Qalabka Barashada IoT ee SunFounder ee ESP32

Tutorial ESP32 38/55 - Xakamaynta LED RGB ee taleefankaaga gacanta | Qalabka Barashada IoT ee SunFounder ee ESP32

Cashigarkani, waxaan ku baran doonaa sida loo xakameeyo LED-ka RGB iyadoo la isticmaalayo qaybta ESP32 ee ka timid xirmada barashada ESP32 ee SunFounder. Adigoo soo dira amarrada kaa yimaada qalalkaaga gacanta, waxaad beddeli kartaa midabka LED-ka ama aad demin kartaa gebi ahaanba. Mashruucani wuxuu ka faa'iideysanayaa awoodaha ESP32, isagoo ka faa'iideysanaya sifooyinka Wi-Fi iyo Bluetooth-ka ee ku dhex jira si isku xirnaan iyo xakameyn aan kala go 'lahayn loo helo.

LED-ka RGB wuxuu ka kooban yahay saddex LED oo kala duwan: casaan, cagaar, iyo buluug, kuwaas oo la isku qasi karo si loo abuuro midabyo kala duwan. Mashruucan, waxaad baran doontaa sida loo xiro LED-ka RGB si sax ah iyo sida loo barnaamijyo ESP32 si uu uga jawaabo amarrada Bluetooth-ka. Casharku wuxuu kaloo ku hagaynaa qaybaha koodka ee lagama maarmaanka u ah sidii loo gaari lahaa shaqadan (fiidiyowga 02:15).

Qalabka La Sharxay

Qaybaha ugu muhiimsan ee mashruucan waxaa ka mid ah kontoroolaha ESP32 iyo LED-ka RGB. ESP32 waa qayb awood badan oo leh Wi-Fi iyo Bluetooth ku dhex jira, taasoo ka dhigaysa mid ku habboon codsiyada IoT. Mashruucan, waxay u shaqeyn doontaa sidii server si ay u hesho amarrada ka imanaya qalabka gacanta oo ay u xakameyso LED-ka RGB si waafaqsan.

LED-ka RGB wuxuu leeyahay afar biin: hal biin oo caadi ah (ama anode ama cathode) iyo saddex biin oo loogu talagalay midabada gaarka ah. Biinka caadiga ahi wuxuu ku xidhmaa ama isha korontada ama dhulka, halka saddexda biin ee kale ay ku xidhmaan biinanka GPIO ee ESP32 iyada oo loo marayo resistors si loo xaddido hadda socda oo loo ilaaliyo LED-yada. Qaabkani wuxuu u oggolaanayaa xakameyn sax ah oo ku saabsan iftiinka midab kasta, isagoo abuuraya midabyo kala duwan oo ballaadhan.

Faahfaahinta Xaashida Xogta

• Hubi qiimayaasha resistor-ka ee saxda ah (caadi ahaan 220 Ohm) si loo xaddido hadda socda ee kanalka LED kasta.
• Hubi qaabka biinka caadiga ah (anode ama cathode) ka hor intaadan xirin.
• Isticmaal PWM si aad u yarayso iftiinka iyo isku qasidda midabka adigoo hagaajinaya calaamadda loo diro LED kasta.
• Ka digtoonow xirista si aad uga fogaato wareegyada gaaban; ku xir hal biin mar.
• Tijaabi midab kasta si gaar ah ka dib markaad qaabayso si aad u xaqiijiso xirista saxda ah.

Tilmaamaha Xirista

Si aad u xirto LED-ka RGB ee ESP32, waxaad ku bilaabaysaa inaad saarto LED-ka RGB ee sabuuraadda breadboard-ka. Biinka dheer waa biinka caadiga ah, kaas oo aad ku xiri doonto ama danab togan (anode caadi ah) ama dhulka (cathode caadi ah). Haddii aad isticmaalayso anode caadi ah, ku xir biinka dheer biinka 3.3V ee ESP32. Cathode caadi ah, ku xir biinka GND.

Marka xigta, qaado saddex 220 Ohm resistors oo ku xir hal daraf oo resistor kasta ah biinanka RGB ee u dhigma ee LED-ka. Ku xir darafyada kale ee resistors-ka biinanka GPIO ee ESP32: ku xir biinka casaan ee LED-ka GPIO 27, biinka cagaar GPIO 26, iyo biinka buluug GPIO 25. Ugu dambeyntii, hubi in biinka caadiga ah si habboon loo xiro iyadoo ku xiran qaabkaaga (anode ama cathode).

Tusaalooyinka Koodka & Sharaxaadda

Koodka mashruucan wuxuu ku bilaabmaa in la qeexo biinanka ku xiran LED-ka RGB. Qaybta soo socota waxay muujinaysaa sida biinanka loo dhawaaqo:

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

Halkan, redPin, greenPin, iyo bluePin waxaa loo qoondeeyay nambarro GPIO gaar ah oo ku yaal ESP32 kanalka midab kasta oo ka mid ah LED-ka RGB.

Shaqada setup-ka, Bluetooth-ka waa la bilaabay, waxaana lagu dabaqay dejinta PWM. Qaybtani waxay muujinaysaa bilowgan:

void setup() {
  Serial.begin(115200);      // Bilaab boortaska taxanaha ah
  setupBLE();                // Bilaab Bluetooth BLE

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

Koodkani wuxuu bilaabaa isgaarsiinta taxanaha ah wuxuuna dejiyaa shaqada Bluetooth-ka isagoo ku xidhaya biinanka LED-ka RGB ee kanaalada PWM si loo xakameeyo.

Ugu dambeyntii, shaqada loop-ka waxay hubisaa farriimaha Bluetooth-ka ee la helay oo waxay hagaajisaa midabka LED-ka si waafaqsan:

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

Qaybtan, haddii qiimaha la helay uu yahay "red", LED-ka waxaa loo dejin doonaa iftiin casaan buuxa iyadoo la isticmaalayo shaqada setColor.

Si aad u fahanto koodka si buuxda, waxaa lagugula talinayaa inaad daawato casharka fiidiyowga halkaas oo koodka buuxa lagu shubo hoosta maqaalka.

Muuujin / Waxa Laga Filan Karo

Marka wax walba la xiro oo koodka la soo geliyo, waxaad awood u yeelan doontaa inaad xakamayso LED-ka RGB qalabkaaga gacanta iyada oo loo marayo Bluetooth. Adigoo soo diraya amarrada sida "red", "green", "blue", iwm, waxaad arki doontaa LED-ka oo midabada u beddelaya si waafaqsan. Haddii aad soo dirto "LED_off", LED-ka RGB wuu demin doonaa. Hubi inaad ka eegto kormeeraha taxanaha ah wixii farriimo cillad-baaris ah si aad u xaqiijiso in amarrada si sax ah loo helayo (fiidiyowga 10:45).

Waqtiyada Fiidiyowga

• 00:00 Bilow
• 1:59 Waa maxay RGB LED?
li>6:01 Midabka RGB oo la sharaxay
• 10:01 Bogga dukumeentiga
• 11:19 Xidhiidhka korontada oo la sharaxay
• 13:34 Doorashada guddiga ESP32 iyo dekedda COM ee Arduino IDE
• 15:15 Koodhka Arduino
• 18:02 Tusaale ahaanshaha xakamaynta RGB LED iyadoo la adeegsanayo taleefankaaga

Sawirro

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