La Modulation de Largeur d’Impulsion

Théorie

Un microcontrôleur permet de gérer des entrées et des sorties. Et les ports d’entrées/sortie peuvent être numérique (DIGITAL) ou analogique (ANALOG).

Les ports analogique nécessite une numérisation, ce qui fait que sur un microcontrôleur, on a souvent plus de port numérique que de ports analogique.

Or parfois sur un port numérique nous voulons pouvoir varier l’intensité du signal. Les cas les plus courant sont : la variation d’intensité d’une LED ou de la vitesse d’un moteur.

Pour cela il existe une technique qui se nomme la Modulation de Largeur d’Impulsion (MLI pour les intimes), souvent nommé par sa dénomination anglaise PWM (pour Pulse Width Modulation).

Donc vu qu’une sortie numérique est soit à 5V soit à 0V et qu’on ne peut pas sortir une tension entre ces 2 bornes, l’idée toute simple de la MLI est de faire varier la pulsation dans le temps pour simuler une valeur de sortie entre les bornes.

En gros on joue sur le rapport cyclique :

Bon la théorie c’est bien, mais avec de la pratique cela devient plus clair.

Pratique

Sur Arduino il y a des broches digitales qui peuvent avoir un mode PWM. Parce que oui, toutes les broches digitales ne le peuvent pas. En voyant le code vous allez comprendre.

Pour illustrer avec un projet, j’ai choisi de faire varier les couleurs d’une LED RGB. En gros c’est 3 LED (une rouge, une verte et une bleu) au sein d’une seule LED. Elle est composée de 4 broches (une pour chacune des 3 LED et une pour la cathode).

Voici une photos du branchement :

Comme on le voit j’ai choisi les ports 3, 5 et 6 car compatible PWM.

Les résistances aux bornes de la LED RGB sont de 220 Ohms, et la cathode est directement branché à la masse.

Le but de notre code est de faire varier la couleur de la LED RGB du bleu au vert, puis du vert au rouge et finalement du rouge au bleu.

Et pour cela on va faire de la MLI sur les broches appropriées de la LED RGB.

Voici ce que cela donne :

Maintenant passons au code :

#define BLUE 3
#define GREEN 5
#define RED 6
#define DELAY_TIME 10
#define MAX_PWM 255

void setup() {
  pinMode(BLUE, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(RED, OUTPUT);
  digitalWrite(BLUE, HIGH);
  digitalWrite(GREEN, LOW);
  digitalWrite(RED, LOW);
}

// Variables declaration
int redValue;
int greenValue;
int blueValue;

void loop() {
  // Blue to Green
  redValue = 0;
  greenValue = 0;
  blueValue = MAX_PWM;

  for(int i = 0; i < MAX_PWM; i++) {
    blueValue -= 1;
    greenValue += 1;
    analogWrite(BLUE, blueValue);
    analogWrite(GREEN, greenValue);
    delay(DELAY_TIME);
  }

  // Green to Red
  redValue = 0;
  greenValue = MAX_PWM;
  blueValue = 0;

  for(int i = 0; i < MAX_PWM; i++) {
    greenValue -= 1;
    redValue += 1;
    analogWrite(GREEN, greenValue);
    analogWrite(RED, redValue);
    delay(DELAY_TIME);
  }

  // Red to Green
  redValue = MAX_PWM;
  greenValue = 0;
  blueValue = 0;

  for(int i = 0; i < MAX_PWM; i++) {
    redValue -= 1;
    blueValue += 1;
    analogWrite(RED, redValue);
    analogWrite(BLUE, blueValue);
    delay(DELAY_TIME);
  }

}

Bon tout d’abord il y a l’initialisation, où on définit nos constantes, où onconfigure et initialise nos ports en sortie, et où on déclare nos variable :

#define BLUE 3
#define GREEN 5
#define RED 6
#define DELAY_TIME 10
#define MAX_PWM 255

void setup() {
  pinMode(BLUE, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(RED, OUTPUT);
  digitalWrite(BLUE, HIGH);
  digitalWrite(GREEN, LOW);
  digitalWrite(RED, LOW);
}

// Variables declaration
int redValue;
int greenValue;
int blueValue;

Les ports PWM peuvent varier de 0 à 255.

0 étant équivalent à un rapport cyclique de 0%, soit 0V sur toute la période.

255 étant équivalent à un rapport cyclique de 100%, soit 5V sur toute la période.

Donc dans la fonction loop() qui est l’endroit où se réalisent les actions durant fonctionnement du dispositif, on initialise les valeurs qui vont aller sur nos sorties, puis à l’aide d’une boucle for on fait varier les valeurs.

On a 3 séquences, donc 3 boucles for. On va étudier la première pour mieux comprendre :

  // Blue to Green
  redValue = 0;
  greenValue = 0;
  blueValue = MAX_PWM;

  for(int i = 0; i < MAX_PWM; i++) {
    blueValue -= 1;
    greenValue += 1;
    analogWrite(BLUE, blueValue);
    analogWrite(GREEN, greenValue);
    delay(DELAY_TIME);
  }

On on s’assure que la valeur bleu est au max (c’est à dire 255) et que les autre sont à 0.

Puis on décrémente petit à petit la valeur bleu, pour augmenter la valeur verte.

Les valeurs sont envoyer sur la sortie via la fonction analogWrite(). Pour une sortie numérique c’est peut commun. C’est pour cela qu’il faut bien s’assurer de choisir un port numérique compatible avec le PWM.

Et pour temporiser, on met une pause de 10ms.

Récap

Pour utiliser le PWM sur Arduino, il faut donc utiliser une broches numérique compatible avec la PWM.

Puis utiliser une variable variant entre 0 et 255.

Et finalement utiliser analogWrite() pour affecter cette variable à notre sortie.

Pour marque-pages : Permaliens.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *