Aquila Reloaded – Chapitre 5 : Utilisation d’une LED de puissance de 100W

Bonjour à tous ! (oh mon Dieu il n’a pas dit « hello world » ^^),

Je continue mon projet « Aquila Reloaded », et on va passer à d’autres tests unitaires, à savoir le pilotage de notre LED de puissance. Nous allons au cours de ce chapitre voir comment allumer et éteindre une LED de puissance à l’aide d’un relais (simple !), ou d’un transistor MOSFET (un peu moins simple !). On verra également comment piloter la puissance d’éclairage de notre LED et comment l’utiliser en mode « stroboscopique ».

Les fondamentaux, comment piloter une sortie ?

En 2 lignes : on configure notre broche en tant que sortie, puis on utilise la fonction « digitalWrite ». C’est l’exemple basique du « blink » dans l’IDE Arduino. Exemple avec la broche 3.

void setup() {
 pinMode(3, OUTPUT);
}

void loop() {
 digitalWrite(3, HIGH);
 //digitalWrite(3, LOW);
}

Bref, passons à la suite ! (je me demande pourquoi je vous parle de ça ! ^^)

Piloter un appareil plus gros

Chaque sortie d’un Arduino est limitée à 20mA. Il est évident qu’il est impossible de relier directement notre LED 100W ou tout autre appareil consommateur (moteur à courant continu) directement à la sortie de notre Arduino. Outre le manque de puissance évident, cela détruirait notre Arduino. Il existe cependant plusieurs solutions :

Utilisation d’un transistor

Le transistor est la base de l’électronique, il peut servir d’amplificateur ou d’interrupteur (en saturation). Le but n’est pas de refaire toute la théorie sur les transistors, il y a de nombreux cours sur Internet expliquant cela. Mais pour résumer, en appliquant au transistor un courant de commande faible (entre la patte « base » et la patte « émetteur » (quelques milliampères), on est capable de piloter un courant plus élevé entre la patte « collecteur » et la patte « émetteur » (plusieurs centaines de milliampères, voire plusieurs ampères). On peut donc l’utiliser comme un interrupteur.

Voici ce que cela donne avec notre Arduino, avec un transistor NPN et une lampe :

La valeur de la résistance R1 n’est pas choisie au hasard, une valeur de 330 ohms laisse passer au maximal 15mA (U = Ri ; i = U / R = 5 / 330 = 0,015 A). Le Arduino étant limité à 20mA par patte, on évite ainsi de le détruire.

Le choix du modèle du transistor Q1 est important : outre le fait qu’il existe deux modèles (NPN et PNP) avec des câblages différents, un transistor est déterminé par son gain ainsi que par son intensité maximale. Un gain trop faible limitera l’intensité maximale, et un transistor avec une intensité maximale trop faible sera détruit en cas de dépassement. Bref, soyez vigilant !

Par ailleurs, selon les niveaux de puissance demandé, un transistor chauffe beaucoup ! Veillez à le refroidir !

Utilisation d’un relais

C’est la solution la plus simple pour les courants de forte puissance ou pour l’utilisation de tensions élevées. Il s’agit ni plus ni moins d’un interrupteur « bouton poussoir » électromécanique. On envoie du courant dans une bobine, le magnétisme pousse une lamelle le long d’un contact, et le courant de puissance peut circuler. Dès que le magnétisme est coupé, le courant de puissance est coupé.

(Crédit schéma)

Les relais consomment un courant qui excède souvent 20mA, ce qui dépasse le seuil de tolérance de la sortie de notre Arduino. On va donc utiliser un petit transistor Q1 qui servira d’intermédiaire (un petit BC337 fait parfaitement l’affaire)

La diode placée « a l’envers » entre les 2 pattes de la bobine du relais permet de protéger le transistor. En effet, lorsqu’une bobine n’est plus alimentée, elle émet une impulsion électrique qui pourrait détruire le transistor. La diode D1 permet d’absorber ce choc en faisant tourner l’impulsion électrique « sur elle-même ». C’est d’ailleurs pour cela qu’on la surnomme « diode de roue libre » 😉 (Attention également si vous utilisez des moteurs ou des selfs.)

Utilisation d’un transistor MOSFET

On a vu comment fonctionnait un transistor, il faut savoir qu’il existe aussi des transistor MOSFET. Leur fonctionnement est bien différent car ils sont pilotés en tension, et non en intensité. Avantage, ils supportent de forts courants sans trop chauffer. Enfin, ils ont une vitesse de commutation rapide, contrairement aux relais.

La terminologie change : oubliez « base », « collecteur » et « émetteur », et parlez plutôt de « gate », « drain » et « source ».

Voyons le câblage :

Comme vous pouvez voir, le câblage du transistor MOSFET Q1 n’est pas très différent d’un transistor traditionnel NPN. A noter que la résistance R1 est facultative car, comme dit précédemment, un MOSFET est piloté en tension. Le courant est donc insignifiant et ne détériorera pas l’Arduino. Par sécurité, pour ma part, j’en place une quand même.

Une différence tout de même par rapport au schéma précédent… J’ai placé une autre résistance, R2, de 1k ohms, entre la Gate et la masse, et ceci pour une raison simple : un MOSFET est un composant CMOS. Et comme vu au chapitre 3, le CMOS a besoin d’un état défini clairement à 0 ou 1. La résistance permet donc de bloquer l’état à 0 en l’absence de signal de l’Arduino (câblage PULL DOWN).

A noter que le transistor MOSFET utilisé sur ce schéma dispose d’une diode de roue libre intégrée (Cas du modèle IRF540N par exemple), c’est donc parfait pour piloter un moteur ou tout type de dispositif avec courant induit.

La aussi, le choix du transistor MOSFET est important, il existe des MOSFET N et des MOSFET P (sur le même modèle que les transistors NPN et PNP). Dans le schéma ci-dessus, il s’agit d’un MOSFET N. En outre, les transistors MOSFET ont aussi une limitation en intensité, et peuvent chauffer également.

Comment réguler la puissance lumineuse

Fonctionnement du PWM

Pour faire simple, le PWM permet de créer une « pseudo tension continue » en produisant un signal haché à haute fréquence fixe, mais avec un rapport cyclique variable. Autrement dit, la tension passe rapidement de 5V à 0V, puis à 5V, puis à 0V. Cela a pour effet de créer une « tension efficace » plus faible.

Le Arduino Nano dispose de 6 broches PWM, il faut cependant savoir qu’elles ne fonctionnent pas toutes à la même fréquence de hachage. Les broches 3, 9, 10 et 11 fonctionnent par défaut à 490.20 Hz, alors que les broches 5 et 6 fonctionnent à 976.56 Hz. Elles n’utilisent pas le même registre, pour plus de détails et pour savoir comment modifier la fréquence de base, je vous invite à aller voir ici.

Pour générer un signal PWM, on peut utiliser la fonction AnalogWrite(), dont le nom peut prêter à confusion car il s’agit bien d’un signal numérique sur une broche numérique.

Les paramètres à passer sont le numéro de la broche ainsi que le niveau désiré, sur 1 octet (0 = mini, 255 = maxi). Exemple ci-dessous avec la broche 3, configuré avec un rapport cyclique de 50% :

AnalogWrite(3, 128);

Si on branche une LED sur la broche concernée, on verra que la luminosité de la LED sera plus faible que si on l’avait tout simplement alimenté à 100% (avec digitalWrite par exemple)

Si on mesure la tension, on aura une valeur d’environ 2,5V, ce qui correspond bien à 50% de 5V. (Dans les faits, si on regarde à l’oscilloscope, on verra que la tension passe rapidement de 0 à 5V, mais ca sera tellement rapide que ce sera insignifiant)

Cas pratique avec des composants gourmands en énergie

Pour piloter la puissance lumineuse de notre LED de 100W, nous allons bien entendu utiliser cette technique. Il est évident qu’un relais mécanique ne pourra pas commuter près de 1000 fois par seconde, cette solution est exclue. Un transistor NPN pourrait convenir, mais il s’échaufferait énormément avec une puissance de 100W, sans compter les pertes d’énergie. Cette solution est également exclue. Il nous reste le transistor MOSFET, et c’est précisément ce composant qui répond parfaitement à nos critères.

Voici un exemple de câblage avec notre LED de 100W. Il est un quasi copié-coller du schéma présenté plus haut dans cet article.

Info importante : l’alimentation utilisée pour la LED de puissance est stabilisée en tension et intensité ! N’utilisez pas une alimentation conventionnelle, faute de quoi vous détruiriez la LED. En effet, qu’elle soit petite ou grosse, une LED doit être limitée en intensité !

Comment créer un mode stroboscope

Pour donner un effet « stroboscope » à notre jeu de lumières, il existe deux méthodes :

  • Soit en utilisant la méthode originelle de l’Aquila : un moteur déplace une roue « gobo » devant la lampe afin de la camoufler ou de la rendre visible. Il joue ainsi le rôle d’obturateur. C’est un mode que l’on retrouve sur beaucoup de matériel scénique en raison du choix technologique des lampes à forte puissance (halogène ou à décharge), il est impossible de les faire clignoter sans les détériorer.
  • Soit en faisant clignoter rapidement la lampe : un bref allumage espacé d’un certain temps éteint.

Avec notre LED de 100W, on peut opter pour les 2 méthodes, mais bien évidemement c’est la 2eme méthode dont je vais vous parler

Le PWM n’est d’aucun recours pour ce besoin, la fréquence la plus basse est bien trop rapide. Il va falloir faire autrement…

On pourrait être tenté par ce code, fortement inspiré de l’exemple « blink » :

unsigned int flashSpeed = 200;

void setup() {
  pinMode(3, OUTPUT);
}

void loop() {
  digitalWrite(3, HIGH);
  delay(5);
  digitalWrite(3, LOW);
  delay(flashSpeed);
}

Cela va fonctionner… mais ce ne sera pas efficace. En effet, l’usage de la fonction « delay() » gèle le programme. Or, notre programme final aura besoin d’être réactif pour traiter les déplacements des moteurs, gérer le signal DMX, et bien plus encore. Donc comment faire ?

Il existe une fonction appelée « millis()« . Cette fonction retourne un nombre de type « unsigned long » correspondant au nombre de millisecondes écoulées depuis le lancement de notre programme. Et c’est précisément la méthode que nous allons utiliser !

Voici un exemple de code :

unsigned long lastLedStateChange = 0;
unsigned int flashSpeed = 200;

void setup() {
  pinMode(3, OUTPUT);
  digitalWrite(3, LOW); 
}

void loop() {
 unsigned long currentMillis=millis();
 
  if(digitalRead(3)) {
    if(currentMillis - lastLedStateChange > 5) {
      digitalWrite(3, LOW);
      lastLedStateChange = currentMillis;
    }
  }
  else {
    if(currentMillis - lastLedStateChange > flashSpeed) {
      digitalWrite(3, HIGH);
      lastLedStateChange = currentMillis;
    }
  }
}

Ici, nous stockons dans une variable globale lastLedStateChange à quel moment nous avons effectué un changement d’état sur notre LED. Ensuite, à chaque tour de loop(), on vérifie l’état de la LED.

  • Si celle-ci est allumée et que le temps écoulé depuis le dernier changement est supérieur à 5ms, on l’éteint.
  • Si celle-ci est arrêtée et que le temps écoulé depuis le dernier changement est supérieur à xx ms, on l’allume.

On obtient ainsi la création de flashs réguliers, avec une durée réglable entre chaque flash, sans pour autant geler le programme.

Astuce : élever la tension de l’alimentation d’origine de l’Aquila

L’alimentation d’origine de l’Aquila fournit 13V alternatif ainsi que 23V alternatif. Or, notre LED a besoin d’une tension de 32 à 35V pour fonctionner. De surcroit il faut aussi la stabiliser à une intensité de 3A.

En redressant le 23V alternatif, on obtient une tension d’environ 28V. C’est clairement insuffisant mais c’est un bon début.

Pour stabiliser l’intensité, on serait tenté d’utiliser un transistor, ou bien une grosse résistance. Avec des puissances de 100W, cela créerait un échauffement non négligeable.

Heureusement, il existe sur le marché des élévateurs de tension (step up) capable de monter à 35V. Et de surcroit on peut les limiter en intensité. Et enfin, le tarif est très abordable. Bingo !

Je vous conseille toutefois, avant de brancher la LED (pour éviter de la cramer), de vérifier dans quel sens les potentiomètres de réglage doivent être tournées. J’ai testé 2 modèles (celui présenté en photo, et un autre), et les 2 avaient 2 sens différents.

Pour ce faire, utilisez une résistance de charge. Pour ma part j’ai pris une résistance de 80 ohms 25W. Branchez également 2 multimètres : un en parallèle pour mesurer la tension en sortie du régulateur, un autre en série pour mesurer l’intensité en sortie. Tournez les 2 vis et vérifiez dans quel sens varie la tension et l’intensité.

Ensuite, mettez les potentiomètres au minimum, et recommencez avec votre LED : amenez là à 32V et 3,00A. Enjoy 😉

Laisser un commentaire

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