Regarder sur YouTube

Tutoriel ESP32 38/55 - Contrôle du LED RGB depuis votre téléphone mobile | Kit d'apprentissage IoT ESP32 de SunFounder

Dans ce tutoriel, nous allons explorer comment contrôler une LED RGB en utilisant un module ESP32 du kit d'apprentissage SunFounder ESP32. En envoyant des commandes depuis votre appareil mobile, vous pouvez changer la couleur de la LED ou l'éteindre complètement. Ce projet exploite les capacités de l'ESP32, tirant parti des fonctionnalités Wi-Fi et Bluetooth intégrées pour une connectivité et un contrôle sans effort.

La LED RGB se compose de trois LEDs individuelles : rouge, vert et bleu, qui peuvent être mélangées pour créer diverses couleurs. Dans ce projet, vous apprendrez à câbler correctement la LED RGB et à programmer l'ESP32 pour répondre aux commandes Bluetooth. Le tutoriel vous guidera également à travers les composants de code nécessaires pour réaliser cette fonctionnalité (dans la vidéo à 02:15).

Matériel expliqué

Les composants principaux de ce projet incluent le microcontrôleur ESP32 et la LED RGB. L'ESP32 est un module puissant avec Wi-Fi et Bluetooth intégrés, ce qui le rend idéal pour les applications IoT. Dans ce projet, il agira comme un serveur pour recevoir des commandes d'un appareil mobile et contrôler la LED RGB en conséquence.

LaLED RGB a quatre broches : une broche commune (soit l'anode, soit la cathode) et trois broches pour les couleurs individuelles. La broche commune se connecte soit à la source d'alimentation, soit à la terre, tandis que les trois autres broches se connectent aux broches GPIO de l'ESP32 via des résistances pour limiter le courant et protéger les LEDs. Ce dispositif permet un contrôle précis de la luminosité de chaque couleur, créant une large gamme de couleurs.

Détails de la fiche technique

• Assurez-vous des valeurs de résistance appropriées (typiquement 220 Ohm) pour limiter le courant dans chaque canal LED.
• Vérifiez la configuration des broches communes (anode ou cathode) avant de câbler.
• Utilisez le PWM pour atténuer et mélanger les couleurs en ajustant le signal envoyé à chaque LED.
• Soyez prudent avec le câblage pour éviter les courts-circuits ; connectez une broche à la fois.
• Testez chaque couleur individuellement après la configuration pour confirmer le câblage correct.

Instructions de câblage

Pour câbler la LED RGB à l'ESP32, commencez par placer la LED RGB sur une plaque de montage. La broche la plus longue est la broche commune, que vous connecterez soit à la tension positive (pour l'anode commune), soit à la terre (pour la cathode commune). Si vous utilisez une anode commune, connectez la broche longue au pin 3,3V de l'ESP32. Pour la cathode commune, connectez-la au pin GND.

Ensuite, prenez trois résistances de 220 Ohms et connectez une extrémité de chaque résistance aux broches RGB correspondantes de la LED. Connectez les autres extrémités des résistances aux broches GPIO de l'ESP32 : connectez la broche rouge de la LED à la GPIO 27, la broche verte à la GPIO 26 et la broche bleue à la GPIO 25. Enfin, assurez-vous que la broche commune est correctement connectée en fonction de votre configuration (anode ou cathode).

Exemples de code et guide étape par étape

Le code de ce projet commence par définir les broches connectées à la LED RGB. L'extrait suivant montre comment les broches sont déclarées :

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

Ici,redPin,greenPin, etbluePinsont attribués des numéros GPIO spécifiques sur l'ESP32 pour chaque canal de couleur de la LED RGB.

Dans la fonction de configuration, le Bluetooth est initialisé et les paramètres PWM sont appliqués. Cet extrait démontre cette initialisation :

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

Ce code initialise la communication série et configure la fonctionnalité Bluetooth tout en attachant les broches LED RVB aux canaux PWM pour le contrôle.

Enfin, la fonction de boucle vérifie les messages Bluetooth reçus et ajuste la couleur des LED en conséquence :

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

Dans cette section, si la valeur reçue est "rouge", la LED sera réglée à la pleine luminosité rouge en utilisant lesetColorfonction.

Pour une compréhension complète du code, il est recommandé de regarder le tutoriel vidéo où le code complet est chargé sous l'article.

Démonstration / À quoi s'attendre

Une fois que tout est câblé et que le code est téléchargé, vous devriez être en mesure de contrôler la LED RGB depuis votre appareil mobile via Bluetooth. En envoyant des commandes comme "rouge", "vert", "bleu", etc., vous verrez la LED changer de couleur en conséquence. Si vous envoyez "LED_off", la LED RGB s'éteindra. Assurez-vous de vérifier le moniteur série pour tout message de débogage afin de confirmer que les commandes sont reçues correctement (dans la vidéo à 10:45).

Horodatage vidéo

• 00:00 Début
• 1:59 Qu'est-ce qu'un LED RGB ?
• 6:01 Explication de la couleur RVB
• 10:01 Page de documentation
• 11:19 Explication du câblage
• 13:34 Sélection de la carte ESP32 et du port COM dans l'IDE Arduino
• 15:15 Code Arduino
• 18:02 Démonstration de contrôle d'une LED RGB avec votre téléphone

Images

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"

 // Définir les broches LED RGB
const int redPin = 27;
const int greenPin = 26;
const int bluePin = 25;

 // Définir la fréquence et la résolution du PWM
const int freq = 5000;
const int resolution = 8;

 // Définir le nom de l'appareil Bluetooth
const char *bleName = "ESP32_Bluetooth";

 // Définissez le texte reçu et l'heure du dernier message.
String receivedText = "";
unsigned long lastMessageTime = 0;

 // Définir les UUID des services et des caractéristiques
#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"

 // Définir la caractéristique Bluetooth
BLECharacteristic *pCharacteristic;

void setup() {
  Serial.begin(115200); // Initialiser le port série
  setupBLE(); // Initialiser le Bluetooth BLE

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

void loop() {
 // Lorsque le texte reçu n'est pas vide et que le temps écoulé depuis le dernier message est supérieur à 1 seconde
 // Envoyer une notification et imprimer le texte reçu
  if (receivedText.length() > 0 && millis() - lastMessageTime > 1000) {
    Serial.print("Received message: ");
    Serial.println(receivedText);
    pCharacteristic->setValue(receivedText.c_str());
    pCharacteristic->notify();
    receivedText = "";
  }

 // Lire les données du port série et les envoyer à la caractéristique BLE.
  if (Serial.available() > 0) {
    String str = Serial.readStringUntil('\n');
    const char *newValue = str.c_str();
    pCharacteristic->setValue(newValue);
    pCharacteristic->notify();
  }
}

 // Définir les rappels du serveur BLE
class MyServerCallbacks : public BLEServerCallbacks {
 // Imprimez le message de connexion lorsqu'un client est connecté.
  void onConnect(BLEServer *pServer) {
    Serial.println("Connected");
  }
 // Imprimez le message de déconnexion lorsqu'un client est déconnecté.
  void onDisconnect(BLEServer *pServer) {
    Serial.println("Disconnected");
  }
};

 // Définir les rappels de caractéristiques BLE
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); // éteindre la LED RVB
      Serial.println("RGB LED turned off");
    } else if (value == "red") {
      setColor(255, 0, 0); // Rouge
      Serial.println("red");
    }
    else if (value == "green") {
      setColor(0, 255, 0); // vert
      Serial.println("green");
    }
    else if (value == "blue") {
      setColor(0, 0, 255); // bleu
      Serial.println("blue");
    }
    else if (value == "yellow") {
      setColor(255, 150, 0); // jaune
      Serial.println("yellow");
    }
    else if (value == "purple") {
      setColor(80, 0, 80); // pourpre
      Serial.println("purple");
    }
  }
};

 // Initialiser le Bluetooth BLE
void setupBLE() {
  BLEDevice::init(bleName); // Initialisez le périphérique BLE
  BLEServer *pServer = BLEDevice::createServer(); // Créez le serveur BLE
 // Imprimez le message d'erreur si la création du serveur BLE échoue.
  if (pServer == nullptr) {
    Serial.println("Error creating BLE server");
    return;
  }
  pServer->setCallbacks(new MyServerCallbacks()); // Définissez les rappels du serveur BLE.

 // Créez le service BLE
  BLEService *pService = pServer->createService(SERVICE_UUID);
 // Imprimez le message d'erreur si la création du service BLE échoue.
  if (pService == nullptr) {
    Serial.println("Error creating BLE service");
    return;
  }
 // Créer la caractéristique BLE pour envoyer des notifications
  pCharacteristic = pService->createCharacteristic(CHARACTERISTIC_UUID_TX, BLECharacteristic::PROPERTY_NOTIFY);
  pCharacteristic->addDescriptor(new BLE2902()); // Ajoutez le descripteur
 // Créer la caractéristique BLE pour recevoir des données
  BLECharacteristic *pCharacteristicRX = pService->createCharacteristic(CHARACTERISTIC_UUID_RX, BLECharacteristic::PROPERTY_WRITE);
  pCharacteristicRX->setCallbacks(new MyCharacteristicCallbacks()); // Définir les rappels de caractéristiques BLE
  pService->start(); // Démarrer le service BLE
  pServer->getAdvertising()->start(); // Commencer à faire de la publicité
  Serial.println("Waiting for a client connection..."); // Attendez une connexion client
}

void setColor(int red, int green, int blue) {
 // Pour les LED RGB à anode commune, utilisez 255 moins la valeur de couleur.
  ledcWrite(redPin, red);
  ledcWrite(greenPin, green);
  ledcWrite(bluePin, blue);
}