Guarda su YouTube

Tutorial ESP32 38/55 - Controllare LED RGB dal tuo telefono cellulare | Kit di apprendimento IoT ESP32 di SunFounder

In questo tutorial, esploreremo come controllare un LED RGB utilizzando un modulo ESP32 del kit di apprendimento SunFounder ESP32. Inviando comandi dal tuo dispositivo mobile, puoi cambiare il colore del LED o spegnerlo completamente. Questo progetto sfrutta le capacità dell'ESP32, utilizzando le funzionalità Wi-Fi e Bluetooth integrate per una connettività e un controllo senza soluzione di continuità.

Il LED RGB è composto da tre LED individuali: rosso, verde e blu, che possono essere mescolati per creare vari colori. In questo progetto, imparerai come cablare correttamente il LED RGB e programmare l'ESP32 per rispondere ai comandi Bluetooth. Il tutorial ti guiderà anche attraverso i componenti di codice necessari per raggiungere questa funzionalità (nel video alle 02:15).

Hardware spiegato

I componenti principali per questo progetto includono il microcontrollore ESP32 e il LED RGB. L'ESP32 è un modulo potente con Wi-Fi e Bluetooth integrati, rendendolo ideale per applicazioni IoT. In questo progetto, agirà come server per ricevere comandi da un dispositivo mobile e controllare il LED RGB di conseguenza.

Il LED RGB ha quattro pin: uno comune (o anodo o catodo) e tre pin per i colori individuali. Il pin comune si collega alla fonte di alimentazione o a terra, mentre gli altri tre pin si collegano ai pin GPIO dell'ESP32 tramite resistori per limitare la corrente e proteggere i LED. Questa configurazione consente un controllo preciso della luminosità di ciascun colore, creando una vasta gamma di colori.

Dettagli della scheda tecnica

• Assicurati di avere valori di resistori appropriati (tipicamente 220 Ohm) per limitare la corrente attraverso ciascun canale LED.
• Controlla la configurazione dei pin comuni (anodo o catodo) prima di cablare.
• Utilizza PWM per il dimming e la miscelazione dei colori regolando il segnale inviato a ciascun LED.
• Fai attenzione con i cablaggi per evitare cortocircuiti; collega un pin alla volta.
• Testa ogni colore singolarmente dopo l'installazione per confermare il cablaggio corretto.

Istruzioni di cablaggio

Per collegare il LED RGB all'ESP32, inizia posizionando il LED RGB su una breadboard. Il pin più lungo è il pin comune, che collegherai o alla tensione positiva (per anodo comune) o a terra (per catodo comune). Se stai utilizzando l'anodo comune, collega il pin lungo al pin 3.3V sull'ESP32. Per il catodo comune, collegalo al pin GND.

Successivamente, prendi tre resistori da 220 Ohm e collega un'estremità di ciascun resistore ai pin RGB corrispondenti del LED. Collega le altre estremità dei resistori ai pin GPIO dell'ESP32: collega il pin rosso del LED al GPIO 27, il pin verde al GPIO 26 e il pin blu al GPIO 25. Infine, assicurati che il pin comune sia collegato correttamente in base alla tua configurazione (anodo o catodo).

Esempi di codice e guida passo passo

Il codice per questo progetto inizia definendo i pin collegati all'LED RGB. Il seguente estratto mostra come vengono dichiarati i pin:

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

Qui,redPin,greenPin, ebluePinsono assegnati numeri GPIO specifici sulla ESP32 per ciascun canale di colore del LED RGB.

Nella funzione di setup, il Bluetooth viene inizializzato e vengono applicate le impostazioni PWM. Questo estratto dimostra questa inizializzazione:

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

Questo codice inizializza la comunicazione seriale e configura la funzionalità Bluetooth collegando i pin LED RGB ai canali PWM per il controllo.

Infine, la funzione loop controlla i messaggi Bluetooth ricevuti e regola di conseguenza il colore del LED:

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

In questa sezione, se il valore ricevuto è "rosso", il LED sarà impostato al massimo della luminosità rossa utilizzando ilsetColorfunzione.

Per una comprensione completa del codice, si consiglia di guardare il video tutorial in cui il codice completo è caricato sotto l'articolo.

Dimostrazione / Cosa Aspettarsi

Una volta che tutto è cablato e il codice è caricato, dovresti essere in grado di controllare il LED RGB dal tuo dispositivo mobile tramite Bluetooth. Inviando comandi come "rosso", "verde", "blu", ecc., vedrai il LED cambiare colore di conseguenza. Se invii "LED_off", il LED RGB si spegnerà. Assicurati di controllare il monitor seriale per eventuali messaggi di debug per confermare che i comandi vengano ricevuti correttamente (nel video alle 10:45).

Timestamp video

• 00:00 Inizio
• 1:59 Cos'è un LED RGB?
• 6:01 Spiegazione del colore RGB
• 10:01 Pagina di documentazione
• 11:19 Spiegazione del cablaggio
• 13:34 Selezionando la scheda ESP32 e la porta COM nell'IDE di Arduino
• 15:15 Codice Arduino
• 18:02 Dimostrazione di controllo di un LED RGB utilizzando il tuo telefono

Immagini

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