Samouczek ESP32 38/55 - Sterowanie diodą RGB z telefonu komórkowego | Zestaw edukacyjny SunFounder ESP32 IoT

Samouczek ESP32 38/55 - Sterowanie diodą RGB z telefonu komórkowego | Zestaw edukacyjny SunFounder ESP32 IoT

W tym samouczku dowiemy się, jak sterować diodą RGB LED za pomocą modułu ESP32 z zestawu edukacyjnego SunFounder ESP32. Wysyłając polecenia z urządzenia mobilnego, możesz zmieniać kolor diody lub całkowicie ją wyłączyć. Ten projekt wykorzystuje możliwości ESP32, korzystając z wbudowanych funkcji Wi-Fi i Bluetooth w celu płynnej łączności i sterowania.

Dioda RGB LED składa się z trzech pojedynczych diod: czerwonej, zielonej i niebieskiej, które można mieszać, aby uzyskać różne kolory. W tym projekcie nauczysz się, jak prawidłowo podłączyć diodę RGB LED i zaprogramować ESP32 do reagowania na polecenia Bluetooth. Samouczek przeprowadzi Cię również przez niezbędne elementy kodu, aby osiągnąć tę funkcjonalność (na filmie o 02:15).

Wyjaśnienie sprzętu

Główne komponenty tego projektu to mikrokontroler ESP32 oraz dioda RGB LED. ESP32 to wydajny moduł z wbudowanym Wi-Fi i Bluetooth, co czyni go idealnym do zastosowań IoT. W tym projekcie będzie działał jako serwer odbierający polecenia z urządzenia mobilnego i odpowiednio sterujący diodą RGB LED.

Dioda RGB LED ma cztery piny: jeden wspólny pin (anoda lub katoda) oraz trzy piny dla poszczególnych kolorów. Wspólny pin łączy się ze źródłem zasilania lub masą, a pozostałe trzy piny łączą się z pinami GPIO ESP32 przez rezystory, aby ograniczyć prąd i chronić diody. Taka konfiguracja umożliwia precyzyjne sterowanie jasnością każdego koloru, tworząc szeroką gamę barw.

Szczegóły z karty katalogowej

• Upewnij się, że używasz odpowiednich wartości rezystorów (zazwyczaj 220 omów), aby ograniczyć prąd płynący przez każdy kanał diody.
• Sprawdź konfigurację wspólnego pinu (anoda lub katoda) przed podłączeniem.
• Użyj PWM do ściemniania i mieszania kolorów, regulując sygnał wysyłany do każdej diody.
• Zachowaj ostrożność podczas podłączania, aby uniknąć zwarć; podłączaj jeden pin na raz.
• Po podłączeniu przetestuj każdy kolor osobno, aby potwierdzić prawidłowe okablowanie.

Instrukcje podłączenia

Aby podłączyć diodę RGB LED do ESP32, zacznij od umieszczenia diody na płytce stykowej. Dłuższy pin to wspólny pin, który podłączysz do dodatniego napięcia (dla wspólnej anody) lub masy (dla wspólnej katody). Jeśli używasz wspólnej anody, podłącz długi pin do pinu 3,3 V na ESP32. Dla wspólnej katody podłącz go do pinu GND.

Następnie weź trzy rezystory 220 omów i podłącz jeden koniec każdego rezystora do odpowiednich pinów RGB diody. Podłącz drugie końce rezystorów do pinów GPIO ESP32: podłącz czerwony pin diody do GPIO 27, zielony pin do GPIO 26, a niebieski pin do GPIO 25. Na koniec upewnij się, że wspólny pin jest odpowiednio podłączony zgodnie z Twoją konfiguracją (anoda lub katoda).

Przykłady kodu i omówienie

Kod tego projektu zaczyna się od zdefiniowania pinów podłączonych do diody RGB LED. Poniższy fragment pokazuje, jak deklarowane są piny:

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

Tutaj redPin, greenPin i bluePin są przypisane do określonych numerów GPIO na ESP32 dla każdego kanału koloru diody RGB LED.

W funkcji setup inicjalizowany jest Bluetooth i stosowane są ustawienia PWM. Ten fragment demonstruje tę inicjalizację:

void setup() {
  Serial.begin(115200);      // Inicjalizacja portu szeregowego
  setupBLE();                // Inicjalizacja Bluetooth BLE

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

Ten kod inicjalizuje komunikację szeregową i konfiguruje funkcjonalność Bluetooth, jednocześnie przypinając piny diody RGB LED do kanałów PWM w celu sterowania.

Na koniec funkcja loop sprawdza odebrane wiadomości Bluetooth i odpowiednio dostosowuje kolor diody:

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

W tej sekcji, jeśli odebrana wartość to "red", dioda zostanie ustawiona na pełną jasność czerwieni za pomocą funkcji setColor.

Aby w pełni zrozumieć kod, zaleca się obejrzenie samouczka wideo, gdzie pełny kod jest załadowany pod artykułem.

Demonstracja / Czego się spodziewać

Po podłączeniu wszystkiego i wgraniu kodu powinieneś być w stanie sterować diodą RGB LED z urządzenia mobilnego przez Bluetooth. Wysyłając polecenia takie jak "red", "green", "blue" itd., zobaczysz, jak dioda zmienia kolory. Jeśli wyślesz "LED_off", dioda RGB LED wyłączy się. Upewnij się, że sprawdzasz monitor szeregowy pod kątem komunikatów debugowania, aby potwierdzić, że polecenia są poprawnie odbierane (na filmie o 10:45).

Znaczniki czasu wideo

• 00:00 Start
• 1:59 Co to jest dioda RGB LED?
• 6:01 Wyjaśnienie kolorów RGB
• 10:01 Strona dokumentacji
• 11:19 Wyjaśnienie podłączenia
• 13:34 Wybór płytki ESP32 i portu COM w Arduino IDE
• 15:15 Kod Arduino
• 18:02 Demonstracja sterowania diodą RGB LED za pomocą telefonu

Obrazy

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