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 :
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=...(1),B=...(2); // 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 ...(3) // affecter la patte G en sortie pour alimenter la LED G ...(4) // affecter la patte B en sortie pour alimenter la LED B ...(5)// 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" ...(6) // vert = 150 reste ds le buffer :";250; +LF" ...(7) // 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 ...(8) // écrire la valeur vert pour la LED G ...(9) // é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()) }
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 %.
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)
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 :
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...