Rouleau de leds RGB 12 volts

Les trois couleurs primaires de la lumière sont rouge, vert et bleu. On les note souvent RVB ou RGB en électronique, par concaténation des initiales françaises ou anglaises (red, green & blue).

Un éclairage utilisant ces trois couleurs permet de reproduire l’ensemble du spectre lumineux, dans la limite de la résolution disponible (les incréments possibles par le circuit de commande pour chacune des couleurs) et du bon mélange des faisceaux de lumière lorsqu’on utilise trois sources distinctes.

Construction

Pour ce petit exercice, on utilise des leds RGB alimentées en 12 volts. On en trouve sous forme de rouleaux de 5 mètres à découper (130 euros). La lumière est produite par de petites leds groupées par 3 dans un même boitier, ces boitiers étant espacés de moins de deux centimètres. Le circuit électronique est organisé de telle façon qu’on puisse n’en utiliser qu’une partie (trois par trois).

Dans notre réalisation d’un démonstrateur pour un bras robotisé, nous avons utilisé ces leds pour illuminer les plaques de plexiglas supportant le bras et son électronique. On a utilisé 9 leds en haut et 15 leds en bas.

Electronique

Produire de la lumière consomme de l’énergie. Une led courante va consommer 20 mA. Les rouleaux qu’on utilise consomment 500 mA par mètre. Il faut donc bien évaluer la consommation totale pour prévoir une source d’alimentation convenable.

Ensuite, la tension de 12 volts nécessite une adaptation du circuit de commande, puisque la majorité des micro-contrôleurs que nous utilisons fonctionnent en 5 ou 3,3 volts.

Les leds du rouleau utilisé sont placées en "anode commune" : le + est commun à toutes les leds, tandis que les cathodes (le -) de chaque diode de chaque couleur sont reliées ensemble et utilisables pour piloter l’éclairage de chaque couleur. On retrouve donc quatre fils : +, R, G et B. Le pilotage des leds consiste donc à laisser passer le courant entre chacune des cathodes et la masse.

Pour réaliser ce contrôle de courant, on utilise des transistors particuliers, à "effet de champ" (Field Effect Transistor en anglais, abrégé en FET) et plus particulièrement les "MOSFET" (des transistors à effet de champ à "grille métal-oxyde" - le S de semi-conducteur ayant sauté dans la traduction française). Ces composants sont petits mais costauds : ils sont capables de contrôler un courant de plusieurs ampères sans chauffer, grâce à une très faible résistance interne. Dans notre cas nous avons choisi un modèle avec boitier plastique TO-92, cylindrique avec une face plate, qui ne pilote que 200 milliampères.

Un MOSFET a trois pattes : la source, la grille et le drain. Notre micro-contrôleur va donc contrôler le passage entre la source (masse) et le drain (cathode des leds à contrôler) en envoyant un signal sur la grille.

Programmation

On va utiliser une carte Arduino pour faire varier l’intensité lumineuse en contrôlant la grille du MOSFET. Le transistor accepte un signal PWM, et la fonction permettant de générer un PWM est simplement :

analogWrite(patte,valeur);

où patte est un numéro identifiant une sortie numérique ("digital" malgré le nom de la fonction) capable de faire du PWM (celles identifiées par une étoile ou un tilde selon votre version) et où valeur est un entier entre 0 et 255.

La résolution est donc de 8 bits (2 puissance 8 soit 256 valeurs) et permettra d’obtenir 256x256x256 soit 16 millions de combinaisons (on parle aussi de 24 bits pour un écran d’ordinateur par exemple) sur les trois couleurs primaires de la lumière.

Fondu enchaîné

Pour un changement progressif d’une couleur à l’autre, on effectue un cycle de 766 changements :
– à 0, le rouge est au maximum (255), le vert est au minimum (0) et le bleu est éteint (0)
– à 255, le rouge est minimum (0), le vert est au maximum (255) et le bleu est éteint (0) = variation rouge et vert
– à 510, le rouge est éteint, le vert est au minimum (255) et le bleu est au maximum (255) = variation bleu et vert
– à 765, le rouge est au maximum (255), le vert est éteint et le bleu est au minimum (0) = variation bleu et rouge

Donc la situation 765 est identique à la situation 0.

Voici le code pour Arduino correspondant. Le circuit utilise les pattes digital 3, 5 et 6 qui sont pourvues de PWM.

/**
 * Effet de variation sur trois couleurs
 * 
 * On utilise des rubans de leds pilotés par PWM
 */

int rouge = 3;
int vert = 5;
int bleu = 6;

long index = 0;

void setup()
{

}

void loop()
{
  if (index <= 255) 
  {
    analogWrite(rouge,255-index);
    analogWrite(vert,index);
    analogWrite(bleu,0);
  } 
  else if (index <= 510) {
    analogWrite(rouge,0);
    analogWrite(vert,510-index);
    analogWrite(bleu,index-255);
  } 
  else if (index <= 764) {
    analogWrite(rouge,index-510);
    analogWrite(vert,0);
    analogWrite(bleu,765-index);
  }
  index++;
  if (index >= 765) {
    index = 0;
  }
  delay(30);
}

Le mystère du MOSFET fantôme

Le code initial avait l’air de fonctionner, mais on trouvait le rouge assez faiblard, affiché peu longtemps par rapport aux deux autres couleurs. En effet avec le voltmètre (merci Mathieu) on ne mesurait que 6 volts au lieu des 12 nominaux. On a cherché plusieurs hypothèses :

– le seuil de déclenchement de l’éclairage est plus élevé pour le rouge que pour les autres couleurs ? Non !
– la led rouge est moins brillante que les autres et l’oeil ne perçoit que la couleur la plus forte ? Que Nenni !
– le rapport cyclique généré par la fonction PWM d’un AVR est moisi et ne vaut pas un bon PIC ? Ah ah...

Après deux heures de tests lors de notre réunion du vendredi, Stephan a finalement trouvé l’erreur, humaine comme de bien entendu... Le développeur (Julien) n’avait tout simplement pas utilisé la bonne patte (2 au lieu de 3) dans son code... Mais c’est une erreur qui a permis de mettre en évidence la très grande réactivité d’un MOSFET : en effet il lui a suffit de capter le courant induit par la proximité des deux pistes (on allume 2 et la patte 3 reliée au MOSFET l’active à moitié).