ESP32 PWM avec Arduino IDE (sortie analogique)

Apprenez à générer des signaux PWM avec l’ESP32 à l’aide de l’IDE Arduino. Nous expliquerons deux méthodes différentes : utiliser analogWrite et utiliser l’API LEDC. À titre d’exemple, nous allons construire un circuit simple pour atténuer une LED.

Mis à jour le 11 juin 2024

Avant de poursuivre ce didacticiel, vous devez avoir installé le module complémentaire ESP32 dans votre IDE Arduino. Suivez le didacticiel suivant pour installer l’ESP32 sur l’IDE Arduino, si ce n’est pas déjà fait.

Ce didacticiel est compatible avec le module complémentaire de la carte ESP32 version 3.X ou supérieure – pour en savoir plus, consultez notre guide de migration.

Table des matières

Pièces requises

Pour suivre ce tutoriel vous avez besoin de ces pièces :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Contrôleur PWM LED ESP32

L’ESP32 dispose d’un contrôleur LED PWM avec 6 à 16 canaux indépendants (selon le modèle ESP32) qui peuvent être configurés pour générer des signaux PWM avec différentes propriétés.

Il existe différentes fonctions que vous pouvez utiliser pour générer des signaux PWM et obtenir les mêmes résultats. Vous pouvez utiliser analogWrite (comme dans les cartes Arduino) ou utiliser les fonctions LEDC.

analogWrite

La fonction la plus basique est analogWrite qui accepte comme arguments le GPIO où l’on souhaite générer le signal PWM et la valeur du rapport cyclique (allant de 0 à 255).

void analogWrite(uint8_t pin, int value);

Par exemple:

void analogWrite(2, 180);

Définir la fréquence et la résolution

Vous pouvez définir la résolution et la fréquence du signal PWM sur une broche sélectionnée à l’aide des fonctions analogWriteResolution et analogWriteFrequency.

Pour définir la résolution :

void analogWriteResolution(uint8_t pin, uint8_t resolution);

Pour régler la fréquence :

void analogWriteFrequency(uint8_t pin, uint32_t freq);

Fonctions LEDC

Vous pouvez également utiliser l’API LEDC Arduino-ESP32. Tout d’abord, vous devez configurer une broche LEDC. Vous pouvez utiliser les fonctions ledcAttach ou ledcAttachChannel.

ledcAttacher

La fonction ledcAttach configure une broche LEDC avec une fréquence et une résolution données. Le canal LEDC sera sélectionné automatiquement.

bool ledcAttach(uint8_t pin, uint32_t freq, uint8_t resolution);

Cette fonction retournera vrai si la configuration réussit. Si false est renvoyé, une erreur se produit et le canal LEDC n’est pas configuré.

ledcAttachChannel

Si vous préférez configurer le canal LEDC manuellement, vous pouvez utiliser la fonction ledcAttachChannel à la place.

bool ledcAttachChannel(uint8_t pin, uint32_t freq, uint8_t resolution, uint8_t channel);

Cette fonction retournera vrai si la configuration réussit. Si false est renvoyé, une erreur se produit et le canal LEDC n’est pas configuré.

ledcÉcrire

Enfin, après avoir défini la broche LEDC à l’aide de l’une des deux fonctions précédentes, vous utilisez la fonction ledcWrite pour définir le rapport cyclique du signal PWM.

void ledcWrite(uint8_t pin, uint32_t duty);

Cette fonction retournera vrai si la définition du cycle de service est réussie. Si false est renvoyé, une erreur se produit et le rapport cyclique n’est pas défini.

Pour plus d’informations et toutes les fonctions du contrôleur LEDC PWM, consultez la documentation officielle.

Varier une LED avec l’ESP32

Pour vous montrer comment générer des signaux PWM avec l’ESP32, nous allons créer deux exemples simples qui atténuent la luminosité d’une LED (augmentent et diminuent la luminosité au fil du temps). Nous fournirons un exemple utilisant analogWrite et un autre utilisant les fonctions LEDC.

Schématique

Câblez une LED à votre ESP32 comme dans le schéma suivant. La LED doit être connectée au GPIO 16.

(Ce schéma utilise la version du module ESP32 DEVKIT V1 avec 30 GPIO – si vous utilisez un autre modèle, veuillez vérifier le brochage de la carte que vous utilisez.)

Remarque : vous pouvez utiliser n’importe quelle broche de votre choix, à condition qu’elle puisse servir de sortie. Toutes les broches pouvant servir de sorties peuvent être utilisées comme broches PWM. Pour plus d’informations sur les GPIO ESP32, lisez : Référence de brochage ESP32 : quelles broches GPIO devez-vous utiliser ?

Exemple ESP32 PWM utilisant analogWrite – Code

Ouvrez votre IDE Arduino et copiez le code suivant. Cet exemple augmente et diminue la luminosité des LED au fil du temps à l’aide de la fonction analogWrite.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-pwm-arduino-ide/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

// the number of the LED pin
const int ledPin = 16;  // 16 corresponds to GPIO 16

void setup() {
  // set the LED as an output
  pinMode(ledPin, OUTPUT);
}

void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    analogWrite(ledPin, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
    // changing the LED brightness with PWM
    analogWrite(ledPin, dutyCycle);
    delay(15);
  }
}

Afficher le code brut

Vous commencez par définir la broche à laquelle la LED est attachée. Dans cet exemple, la LED est attachée au GPIO 16.

const int ledPin = 16;  // 16 corresponds to GPIO 16

Dans setup(), vous devez configurer la LED comme sortie à l’aide de la fonction pinMode().

pinMode(ledPin, OUTPUT);

Dans la boucle(), vous faites varier le rapport cyclique entre 0 et 255 pour augmenter la luminosité de la LED.

// increase the LED brightness
for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
  // changing the LED brightness with PWM
  analogWrite(ledPin, dutyCycle);
  delay(15);
}

Notez l’utilisation de la fonction analogWrite() pour configurer le rapport cyclique. Il vous suffit de passer en arguments le pin LED et le duty cycle.

analogWrite(ledPin, dutyCycle);

Enfin, on fait varier le rapport cyclique entre 255 et 0 pour diminuer la luminosité.

// decrease the LED brightness
for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
  // changing the LED brightness with PWM
  analogWrite(ledPin, dutyCycle);
  delay(15);
}

Tester l’exemple

Téléchargez le code sur votre ESP32. Assurez-vous d’avoir sélectionné la bonne carte et le bon port COM. Regardez votre circuit. Vous devriez avoir un variateur LED qui augmente et diminue la luminosité au fil du temps.

Exemple ESP32 PWM utilisant l’API LEDC – Code

Ouvrez votre IDE Arduino et copiez le code suivant. Cet exemple augmente et diminue la luminosité des LED au fil du temps à l’aide des fonctions ESP32 LEDC.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-pwm-arduino-ide/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

// the number of the LED pin
const int ledPin = 16;  // 16 corresponds to GPIO16

// setting PWM properties
const int freq = 5000;
const int resolution = 8;
 
void setup(){
  // configure LED PWM
  ledcAttach(ledPin, freq, resolution);
  
  // if you want to attach a specific channel, use the following instead
  //ledcAttachChannel(ledPin, freq, resolution, 0);
}
 
void loop(){
  // increase the LED brightness
  for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
    // changing the LED brightness with PWM
    ledcWrite(ledPin, dutyCycle);
    delay(15);
  }

  // decrease the LED brightness
  for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
    // changing the LED brightness with PWM
    ledcWrite(ledPin, dutyCycle);   
    delay(15);
  }
}

Afficher le code brut

Vous commencez par définir la broche à laquelle la LED est attachée. Dans cet exemple, la LED est attachée au GPIO 16.

const int ledPin = 16;

Définissez les propriétés PWM : fréquence et résolution.

// setting PWM properties
const int freq = 5000;
const int resolution = 8;

Comme nous utilisons une résolution de 8 bits, le rapport cyclique sera contrôlé en utilisant une valeur comprise entre 0 et 255.

Dans setup(), configurez la broche LEDC : utilisez la fonction ledcAttach comme suit.

ledcAttach(ledPin, freq, resolution);

Cela configurera la broche LEDC avec la fréquence et la résolution définies précédemment sur un canal PWM par défaut.

Si vous souhaitez configurer vous-même le canal PWM, vous devez plutôt utiliser ledcAttachChannel. Le dernier argument de cette fonction est le numéro de canal PWM.

ledcAttachChannel(ledPin, freq, resolution, 0);

Enfin, dans la boucle(), vous augmentez et diminuez la luminosité de la LED au fil du temps.

Les lignes suivantes augmentent la luminosité des LED.

// increase the LED brightness
for(int dutyCycle = 0; dutyCycle <= 255; dutyCycle++){   
  // changing the LED brightness with PWM
  ledcWrite(ledPin, dutyCycle);
  delay(15);
}

Notez l’utilisation de la fonction ledcWrite() pour configurer le rapport cyclique. Il vous suffit de passer en arguments le pin LED et le duty cycle.

ledcWrite(ledPin, dutyCycle);

Enfin, on fait varier le rapport cyclique entre 255 et 0 pour diminuer la luminosité.

// decrease the LED brightness
for(int dutyCycle = 255; dutyCycle >= 0; dutyCycle--){
  // changing the LED brightness with PWM
  ledcWrite(ledPin, dutyCycle);   
  delay(15);
}

Tester l’exemple

Téléchargez le code sur votre ESP32. Assurez-vous d’avoir sélectionné la bonne carte et le bon port COM. Regardez votre circuit. Vous devriez avoir un variateur LED qui augmente et diminue la luminosité au fil du temps, tout comme dans l’exemple précédent.

Conclusion

En résumé, dans cet article, vous avez appris à utiliser le contrôleur LED PWM de l’ESP32 avec l’IDE Arduino pour atténuer une LED. Les concepts appris peuvent être utilisés pour contrôler d’autres sorties avec PWM en définissant les bonnes propriétés du signal.

Nous avons d’autres ressources ESP32 qui pourraient vous plaire :

Ceci est un extrait de notre cours : Apprenez l’ESP32 avec l’IDE Arduino. Si vous aimez ESP32 et souhaitez en savoir plus, nous vous recommandons de vous inscrire au cours Apprendre ESP32 avec Arduino IDE.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :