Assista no YouTube

Tutorial ESP32 38/55 - Controlando LED RGB pelo seu telefone móvel | Kit de aprendizado IoT ESP32 da SunFounder

Neste tutorial, vamos explorar como controlar um LED RGB utilizando um módulo ESP32 do kit de aprendizagem SunFounder ESP32. Enviando comandos do seu dispositivo móvel, você pode mudar a cor do LED ou desligá-lo completamente. Este projeto aproveita as capacidades do ESP32, utilizando recursos de Wi-Fi e Bluetooth integrados para uma conectividade e controle sem costura.

O LED RGB consiste em três LEDs individuais: vermelho, verde e azul, que podem ser misturados para criar várias cores. Neste projeto, você aprenderá como conectar corretamente o LED RGB e programar o ESP32 para responder a comandos Bluetooth. O tutorial também o guiará pelos componentes de código necessários para alcançar essa funcionalidade (no vídeo às 02:15).

Hardware Explicado

Os componentes principais para este projeto incluem o microcontrolador ESP32 e o LED RGB. O ESP32 é um módulo poderoso com Wi-Fi e Bluetooth integrados, tornando-o ideal para aplicações de IoT. Neste projeto, ele atuará como um servidor para receber comandos de um dispositivo móvel e controlar o LED RGB de acordo.

O LED RGB tem quatro pinos: um pino comum (ou ânodo ou cátodo) e três pinos para as cores individuais. O pino comum conecta-se à fonte de alimentação ou ao terra, enquanto os outros três pinos conectam-se aos pinos GPIO do ESP32 através de resistores para limitar a corrente e proteger os LEDs. Essa configuração permite o controle preciso do brilho de cada cor, criando uma ampla gama de cores.

Detalhes da Ficha Técnica

• Assegure valores de resistor adequados (tipicamente 220 Ohm) para limitar a corrente em cada canal de LED.
• Verifique a configuração comum do pino (ánodo ou cátodo) antes de fazer a fiação.
• Use PWM para atenuação e mistura de cores ajustando o sinal enviado a cada LED.
• Tenha cuidado com a fiação para evitar curto-circuitos; conecte um pino de cada vez.
• Teste cada cor individualmente após a configuração para confirmar a fiação correta.

Instruções de fiação

Para conectar o LED RGB ao ESP32, comece colocando o LED RGB em uma placa de ensaio. O pino mais longo é o pino comum, que você conectará ao positivo (para o ánodo comum) ou ao terra (para o cátodo comum). Se você estiver usando um ánodo comum, conecte o pino longo ao pino de 3,3V no ESP32. Para cátodo comum, conecte-o ao pino GND.

Em seguida, pegue três resistores de 220 Ohm e conecte uma extremidade de cada resistor aos pinos RGB correspondentes do LED. Conecte as outras extremidades dos resistores aos pinos GPIO do ESP32: conecte o pino vermelho do LED ao GPIO 27, o pino verde ao GPIO 26 e o pino azul ao GPIO 25. Por fim, certifique-se de que o pino comum esteja conectado adequadamente com base na sua configuração (ânodo ou cátodo).

Exemplos de Código e Passo a Passo

O código para este projeto começa com a definição dos pinos conectados ao LED RGB. O trecho a seguir mostra como os pinos são declarados:

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

Aqui,redPin,greenPin, ebluePinsão atribuídos números GPIO específicos no ESP32 para cada canal de cor do LED RGB.

Na função de configuração, o Bluetooth é inicializado e as configurações de PWM são aplicadas. Este trecho demonstra essa inicialização:

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

Este código inicializa a comunicação serial e configura a funcionalidade Bluetooth, conectando os pinos do LED RGB aos canais PWM para controle.

Por fim, a função de loop verifica as mensagens Bluetooth recebidas e ajusta a cor do LED de acordo.

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

Nesta seção, se o valor recebido for "vermelho", o LED será definido para brilho vermelho total usando osetColorfunção.

Para uma compreensão completa do código, recomenda-se assistir ao vídeo tutorial onde o código completo está carregado abaixo do artigo.

Demonstração / O que Esperar

Uma vez que tudo esteja conectado e o código tenha sido carregado, você deve ser capaz de controlar o LED RGB a partir do seu dispositivo móvel via Bluetooth. Ao enviar comandos como "vermelho", "verde", "azul", etc., você verá o LED trocar de cores de acordo. Se você enviar "LED_desligado", o LED RGB será desligado. Certifique-se de verificar o monitor serial para quaisquer mensagens de depuração para confirmar que os comandos estão sendo recebidos corretamente (no vídeo às 10:45).

Marcas de Tempo do Vídeo

• 00:00 Início
• 1:59 O que é RGB LED?
• 6:01 Cor RGB explicado
• 10:01 Página de documentação
• 11:19 Fiação explicada
• 13:34 Selecionando a placa ESP32 e a porta COM no Arduino IDE
• 15:15 Código Arduino
• 18:02 Demonstração de controle de LED RGB usando seu telefone

Imagens

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