LED RGB

Introduction

Faire clignoter une LED ou une séquence de LEDs c'est vraiment très sympa.

Ce qui est encore mieux, c'est de contrôler la couleur d'une LED. Cela est rendu possible à l'aide d'une LED particulière dite "RGB" ou "RVB". Elle est en fait composée de 3 LEDs de couleurs différentes enfermées dans un seul et même composant. Les meilleures LEDs RGB seront les LEDs dite à diffusion (LEDs tricolores diffuses).

Ce qui est appréciable avec les LED tricolores diffuses c'est que le mélange des couleurs se fait à l'intérieur de la LED (au lieu d'afficher les couleurs séparemment sur 3 LEDs de couleurs différentes et de faire un mélange "visible").

D'une façon générale, il est préférable d'utiliser une LED tricolores à Anode Commune. L'anode commune signifie que vous connectez la broche commune au +5 Volts et que vous raccordez ensuite les autres broches à la masse au travers d'une résistance. Les LEDs tricolores à Anode Commune sont les plus répandues.

Finalement, il est plus approprié d'utiliser des LEDs RGB à anode commune (le +5 volts commun) plutôt que des LEDs à Cathode Commune (le GND/masse en commun) parce que les circuits intégrés contrôleurs multi-LED (multi-LED driver) tel que le TLC5940/TLC5941 sont souvent conçus pour des Anodes Communes (et ne peuvent pas être utilisés avec des Cathodes Communes).

Ou acheter

Cet article est disponible chez MC Hobby (to change!).

Il inclus les résistances nécessaires au montage :-)

Le montage

Le montage est relativement simple.

Dans un premier temps, il faut bien observer la LED pour identifier les différents broches correspondant aux différentes couleurs. La longueur des différentes broches vous y aidera.

Le côté plats de la diode se trouve sur la droite. Opérez une rotation d'un demi-tour par rapport à la première image de cette section.

Principe de fonctionnement

La LED RGB utilise une anode commune (le + est en commun). Il faut donc manipuler la tension sur les broches négatives des différentes LEDs de couleur.

Pour résumer le fonctionnement:

• On allume une LED de couleur en mettant la broche/pin à 0 volts.
• On éteint une LED en mettant la broche/pin à +5 volts.

Dans le même ordre d'idée, le contrôle PWM fonctionne à l'identique.

• Assigner une valeur 255 en PWM (100% de cycle utile) éteint la LED.
• Assigner une valeur 30 en PWM (30% de cycle utile) allume la LED à 70%.
• Assigner une valeur 0 en PWN (0% de cycle utile) allume la LED à 100%.

Le code

Le code utilise la fonction couleursSimple active successivement chacune des 3 couleurs de base de la LED RGB (par activation de la sortie correspondante).

En modifiant un peu le code de la fonction, vous pourrez mixer deux ou trois couleurs ensembles (ex: vert + bleu).

Le programme dispose également de la fonction couleursFondue qu'il est possible d'appeler depuis loop() en retirant le commentaire.

Cette fonction passe d'une couleur à l'autre en fondue enchaîné en suivant la séquence Rouge --> Vert --> Bleu --> Rouge --> Vert --> ...

 int ledRougePin = 9; // PWM
int ledVertPin = 10; // PWM
int ledBleuPin = 11; // PWM

void setup(){
  pinMode( ledRougePin, OUTPUT );
  pinMode( ledVertPin, OUTPUT );
  pinMode( ledBleuPin, OUTPUT );
  
  //La LED RGB utilise une anode commune (le + en commun.
  //Il faut donc manipuler la tension sur les broches négatives
  //de la LED.
  //
  //Pour résumer:
  //  On allume une LED en mettant la broche/pin à 0 volts
  //  On eteind une LED en mettant la broche/pin à 5 volts
  
  // Tout éteindre
  digitalWrite( ledRougePin, HIGH ); 
  digitalWrite( ledVertPin, HIGH ); 
  digitalWrite( ledBleuPin, HIGH ); 
}

/*
  Active une couleur à la fois.
  Vous pouvez modifier le code pour allumer plusieurs couleurs
    en meme temps.
 */
void couleursSimple(){
  // allumer Vert
  digitalWrite( ledRougePin, HIGH ); 
  digitalWrite( ledVertPin, LOW ); 
  digitalWrite( ledBleuPin, HIGH ); 
  // Attendre 1 sec
  delay( 1000 );
  // allumer Rouge
  digitalWrite( ledRougePin, LOW ); 
  digitalWrite( ledVertPin, HIGH ); 
  digitalWrite( ledBleuPin, HIGH ); 
  // Attendre 1 sec
  delay( 1000 );
  // allumer Bleu
  digitalWrite( ledRougePin, HIGH ); 
  digitalWrite( ledVertPin, HIGH ); 
  digitalWrite( ledBleuPin, LOW ); 
  // Attendre 1 sec
  delay( 1000 );
}

/* 
   Cette fonction passe d'une couleur à l'autre en fondue
   enchainé dans l'ordre suivant:
     Rouge -> Vert --> Bleu --> Rouge --> Vert --> ...
 */
void couleursFondue(){
  // allumer Rouge
  digitalWrite( ledRougePin, LOW ); 
  digitalWrite( ledVertPin, HIGH ); 
  digitalWrite( ledBleuPin, HIGH ); 
  // Ajouter progressivement du vert
  // Retirer progressivement du rouge
  //   attention: 255 = pas de couleur, 0 = max de couleur
  for( int iVert = 255; iVert>0; iVert-- ) {
    int iRouge = 255 - iVert;
    analogWrite( ledRougePin, iRouge );
    analogWrite( ledVertPin, iVert );
    delay( 20 );
  }
  // Ajouter progressivement du bleu
  // Retirer progressivement du vert
  //   attention: 255 = pas de couleur, 0 = max de couleur
  for( int iBleu = 255; iBleu>0; iBleu-- ) {
    int iVert = 255 - iBleu;
    analogWrite( ledVertPin, iVert );
    analogWrite( ledBleuPin, iBleu );
    delay( 20 );
  }
  // Ajouter progressivement du rouge
  // Retirer progressivement du bleu
  //   attention: 255 = pas de couleur, 0 = max de couleur
  for( int iRouge = 255; iRouge>0; iRouge-- ) {
    int iBleu = 255 - iRouge;
    analogWrite( ledBleuPin, iBleu );
    analogWrite( ledRougePin, iRouge );
    delay( 20 );
  }
}

void loop(){
  couleursSimple();
  //couleursFondue();
}