Techniques Physiques
Pour L'Industrie et le Laboratoire
DébutTP 1UARTLED RGBBilanCapteursDataloggingStationUltrasonCAN serieRégulation

Contrôler une LED RGB à l'aide du moniteur série

Principe de fonctionnement :

La LED RGB possède une cathode commune (la masse est commune). C'est la patte la plus longue. (Il existe aussi des LED RGB à anode commune).

On allume une LED de couleur en mettant la broche/pin à 5 volts. Pour limiter le courant on met une résistance de protection de 330 Ohm par exemple
 I = U/R = (5 - 2)/330 = 9 mA
pour la LED rouge qui a une tension de seuil de 2 V.

La modulation de largeur d'impulsions (MLI ; en anglais : Pulse Width Modulation, soit PWM)
permet de faire varier simplement  la valeur moyenne de la tension aux bornes d'un composant.
Une vidéo explicative est disponible sur U=RI

Pour cela il suffit de faire varier le rapport cyclique : alpha = ton/T
ton : temps à l'état haut sur une période (ton < T)
T : période du signal

Pour une alimentation E = 5 V la valeur moyenne obtenue en sortie de la PWM vaut : <U> = alpha * E

Le contrôle PWM permet de contrôler l'intensité lumineuse de chaque diode :

PWM = 255 : rapport cyclique de 255/255 = 1,  la LED est allumée à son maximum : <U> = 1*5 = 5 V et  <i> = 9 mA

PWM = 191 : rapport cyclique de  191/255 = 0,75, le courant moyen dans la LED : <U> = 0,75*5 = 3,75 V   et  <i> = 6,8 mA

PWM = 127 : rapport cyclique de     ........................, le courant moyen dans la LED : <U> =........................  V  et  <i> = ?    mA

PWM = 64   : rapport cyclique de     ........................, le courant moyen dans la LED : <U> =........................  V  et  <i> = ?    mA

PWM =   0 :  rapport cyclique de    0 % , la LED est éteinte.


La fonction analogWrite()  permet de piloter une sortie PWM ~ (digital pin ~ 3,5,6,9,10,11), à l'aide d'une seule instruction.

Syntaxe : analogWrite(broche,PWM);
analogWrite(3,191); // Sortie PWM sur la patte 3, avec un rapport cyclique alpha = 191/255 = 75 %




Objectifs du programme :

Piloter à l'aide du moniteur série la LED en envoyant un message du type : 50;150;250;

Ce message comporte moins de 64 caractères : il sera stocké sans problème dans le buffer série (mémoire tampon)  de l'Arduino.

50;150;250; signifie :

  • Intensité de la LED rouge 50/255 (20%)  ;
  • Intensité de la LED verte 150/255 (59%) ;
  • Intensité de la LED bleue 250/255 (98 %) ;

Par la suite nous pourrons contrôler sans modifier le programme Arduino la LED par Labview ou par un téléphone portable Android grâce à App Inventor.

Pour décoder les instructions reçues par l'Arduino nous allons utiliser la fonction :

Serial.parseInt() : retourne le premier entier (format unsigned long : de 0 à 4 294 967 295  = 232 - 1  ) contenu dans le buffer série. Les caractères qui ne sont pas des chiffres (notamment le signe -) sont ignorés. Serial.parseInt()  arrête de lire le buffer série au premier caractère qui n'est plus un chiffre.

Exemple : « R = 50  ; G=150 ; B = 250; » Serial.parseInt() renvoie 50. Il reste alors dans le buffer «  ; G=150 ; B = 250;»

Réalisation :

1) Les tensions de seuil des diodes verte (G) et bleu (B) sont de 3,2 V.
    On met une résistance de protection de 220 Ohm,
    calculer le courant Imax qui traverse ces diodes.

2) Pour vous aider à commencer voici un programme à compléter qui répond au cahier des charges.

     Chaque zone signalée par ... doit-être complétée par vous en vous inspirant de la ligne précédente.

Appel : faites valider votre programme par le professeur

/*
Transmission par liaison série de la commande d'une LED RGB
Format de transmission retenu : "rouge;vert;bleu;" exemple : 50;150;250; +LF (code ascii 10)
Programme incomplet : il faut compléter le programme dans les zones signalées par ...
*/

/* 1) Zone 1 : les déclarations */

// 1.b) Les Constantes 
const int R=9,G=...,B=...;
// 1.c) Les variables globales
int rouge=0,vert=0,bleu=0,car;

/* 2) Zone 2 : Initialisation (le setup) */
void setup()
{
  pinMode(R, OUTPUT); // affecter la patte R en sortie pour alimenter la LED R
  ... // affecter la patte G en sortie pour alimenter la LED G
  ... // affecter la patte B en sortie pour alimenter la LED B
  ...// Initialiser la liaison série Serial à 9600 bauds
  Serial.println("Format de transmission retenu : rouge;vert;bleu exemple : 50;150;250");
}

/* 3) Zone 3 : le Programme Principal */
void loop()
{
   if (Serial.available()) {   // Si le buffer série reçoit des données : on lit le buffer série
                               // Exemple buffer = "50;150;250; +LF" 
     delay(100);             // Attendre la fin de transmission           
     
     rouge=Serial.parseInt(); // rouge = 50 reste ds le buffer :";150;250; +LF" 
     ... // vert = 150 reste ds le buffer :";250; +LF"
     ... // bleu = 250 reste ds le buffer :"; +LF"

     while (Serial.available()) Serial.read();  // Vider le buffer Serial s'il reste des caractères...  
     
     analogWrite(R,rouge);   // écrire la valeur rouge pour la LED R 
     ... // écrire la valeur vert pour la LED G 
     ... // écrire la valeur bleu pour la LED B
     
     Serial.print("Rouge = "); Serial.print(rouge);  // Afficher le résultat sur le moniteur série
     Serial.print("\t Vert = "); Serial.print(vert);
     Serial.print("\t Bleu = "); Serial.println(bleu);
                             }   // fin de  if (Serial.available())
}

Le programme complété...

Conception Mise en Oeuvre

Cahier des charges :

3) Réaliser un générateur de signaux rectangulaires, de fréquence 1 kHz, de rapport cyclique réglable entre 10% (par valeur supérieure) et 90% (par valeur inférieure).

     Remplir ce cahier des charges avec une tolérance de 5 %.

    Ce générateur alimente la patte de la LED Rouge. Visualiser cette sortie de l'Arduino sur un oscilloscope.
   
Pour cela mettre en oeuvre un programme Arduino répondant à ce cahier des charges.
    La commande du rapport cyclique peut-être réalisée par le moniteur série (cf programme ci-dessus) ou par un potentiomètre relié à une entrée analogique de l'Arduino.
    Vérifier le bon fonctionnement de votre programme à l'aide d'un oscilloscope ou d'un analyseur logique.

Appel : faites valider votre programme par le professeur puis imprimez-le.

Aide pour la commande par un potentiomètre :

Fonctions clés à utiliser : pinMode() ; analogWrite() ;  analogRead() ;

                                        map(value, fromLow, fromHigh, toLow, toHigh)

 Syntaxe :

map (valeur, limite_basse_source, limite_haute_source, limite_basse_destination, limite_haute_destination)

Paramètres

    valeur : le nombre à ré-étalonner

    limite_basse_source: la valeur de la limite inférieure de la fourchette de départ

    limite_haute_source: la valeur de la limite supérieure de la fourchette de départ

    limite_basse_destination: la valeur de la limite inférieure de la fourchette de destination

    limite_haute_destination: la valeur de la limite supérieure de la fourchette de destination

Valeur renvoyée : la valeur ré-étalonnée

val = map(val, 0, 1023, 25, 230); //  valeur initiale entre 0 et 1023 vers une fourchette entre 25 et 230

Arduino pour les nuls :

Vous avez du mal à commencer : voici la structure d'un  programme prérempli avec des commentaires...

Le défi :

4) Remplir le cahier des charges avec une tolérance de 1 % seulement.

La fréquence doit donc être comprise entre 990 Hz et 1010 Hz : la fonction analogWrite() n'est pas adaptée...

Une piste : cet extrait de programme réalise une sortie ayant un rapport cyclique de 45 % et une période de 1 ms = 1000 µs

    unsigned long t0; // Déclare une variable de type long (32 bits) non signé.
    t0=micros();    // top départ, to =  horloge de l'arduino en µs
    digitalWrite(sortie,HIGH); // Sortie à l'état haut
    while(micros()-t0 < 450);  // de 0 à 450 µs (ton)
    digitalWrite(sortie,LOW);  // puis de 450 µs à 1000 µs état bas (toff)
    while(micros()-t0 < 1000); // attente de la fin de la période

Cette structure d'attente avec des boucles while est plus précise que la fonction delay : elle permet de prendre en considération le temps d'exécution des fonctions précédentes.

Arduino pour les nuls : affiche la structure du programme avec des commentaires.

Toujours en difficulté ?  Le corrigé.

Appel : faites valider votre programme par le professeur puis imprimez-le.

Pour aller plus loin :

Une lecture approfondie de la gestion des interruptions du microcontrôleur montre qu'il est possible de faire varier la fréquence des sorties PWM.

Pour cela il faut manipuler les registres.

En jouant sur 3 registres il est possible de contrôler la fréquence de notre PWM :

  • TCCR2B  nous permet de diviser la fréquence d'horloge de 16 000 KHz par 64 pour obtenir une horloge à 250 KHz pour le timer 2  (pattes 3 et 11)
  • OCR2A  règle le max de la rampe numérique qui est par défaut à 255 (f = 250kHz/(255+1) = 0,976 kHz ) en le mettant à 249  (f = 250kHz/(249+1) = 1 kHz )
  • OCR2B  (patte 3) qui est comparé à la rampe numérique pour obtenir la PWM et faire varier le rapport cyclique alpha = OCR2B / OCR2A  

Voici un exemple de programme répondant au cahier des charges.

Le mode 7 Fast PWM (fixé par le registre TCCR2A) permet de fixer le maximum à OCR2A au lieu de 255.

Application - Commande d'un hacheur série

5) Faites varier la vitesse d'un moteur à courant continu à l'aide d'un hacheur commandé par la sortie PWM de votre Arduino.

Le transistor utilisé comme interrupteur commandé par l'Arduino est un transistor MOS IRF640.
Principe d'un hacheur série.

  • lorsqu'on applique une tension VGS = 5 V, IRF640 se comporte entre D (le drain) et S (la source) comme un interrupteur fermé,
    phase d'alimentation, le générateur E alimente le moteur et les bobinages emmagasinent de l'énergie magnétique.

  • lorsqu'on applique une tension VGS = 0 V, IRF640 se comporte entre D (le drain) et S (la source) comme un interrupteur ouvert,
    phase de récupération, le bobinage du moteur restitue l'énergie magnétique emmagasinée.
    Le courant qui ne peut plus passer par le transistor bloqué passe par la diode de roue libre.

  • Sans  diode de roue libre une surtension apparait aux bornes du transistor ce qui entraine sa destruction.

Appel : faites valider votre montage par le professeur

             

Par la suite nous pourrons dialoguer avec l'Arduino, grâce à Labview, par une interface graphique pour remplacer le moniteur série.

Vous pouvez faire un essai en téléchargeant le programme ci-dessous. (cliquez sur l'image)

Pour aller plus loin : piloter la LED RGB avec son téléphone.

Il n'y a aucune modification a apportée au programme LED

Il suffit de relier à l'Arduino un module Bluetooth HC05 ou HC06.

Il faut croiser les fils : Tx  du HC05 vers Rx  de l'Arduino
                                     Rx du HC05 vers Tx  de l'Arduino

Attention : lors du téléversement du programme il faut déconnecter les pattes Rx et Tx du HC06 pour éviter les conflits.

L'application du portable a été réalisée à l'aide de App Inventor.

Il faut un compte Google pour vous connecter et sauver vos programmes.
Ensuite vous pouvez importer cette application au format .aia  et la modifier.

Si vous souhaitez tester cette possibilité : voici un lien pour télécharger l'application Android LED RGB  (format .apk)  créée par d'anciens étudiants TPIL..

Voici le programme App Inventor et une vidéo sur la réalisation de ce programme :

Pour vous entraîner, essayer de recopier ce programme à l'aide des vidéos ci-dessous.

Vidéo 1 : le Bluetooth (BT)

Sélectionner le mode HD 1080p pour obtenir une image bien nette...


Cette partie de programme initialise la liaison Bluetooth.

  permet d'initialiser quel type de liste nous allons créer.
bloc événement

  affecte à ListPicker1 la liste des périphériques BT appairés avec le téléphone.
bloc propriétés

lorsque l'on clique sur la liste... App Inventor fonctionne par événement seulement...
bloc événement

on vérifie que l'on est pas déjà connecté pour ne pas générer d'erreur.

Vidéo 2 : les glissières

La LED RGB est controlée à l'aide de 3 glissières (variant de 0 à 255)
qui envoient par Bluetooth le message R;G;B : 100;150; 25;
Attention sur la vidéo il manque le dernier ;

Vidéo 3 : le bouton couleur

Le bouton couleur affiche la couleur théorique de la LED et si on appuie dessus la LED s'éteint.

Vidéo 4 : la réponse de l'Arduino

App Inventor fonctionne par évènement uniquement.

Ici nous allons créer un événement toutes les 200 ms grâce à Clock1.
Ainsi nous avons une boucle cadencée à 200 ms.

Toutes les 200 ms, App Inventor vérifie si de nouveaux octets sont disponibles et les affiche.

Remarque :par rapport à la vidéo, le test BT connecté a été ajouté.
Cela évite d'avoir un message d'erreur sur le téléphone...