Les LED à couleur RVB à cathode commune sont un type de LED qui offre une variété de couleurs et de nuances. Elles sont utilisées dans de nombreuses applications, notamment l’éclairage décoratif, l’affichage à cristaux liquides et les systèmes d’éclairage à DEL. Dans cet article, nous allons examiner le test d’une LED couleur RVB à cathode commune et discuter des résultats obtenus. Nous examinerons également les différentes méthodes de test et les facteurs à prendre en compte lors du choix d’une LED à couleur RVB à cathode commune.
Test d’une LED couleur RVB à cathode commune
1. Présentation
- Ce programme teste simplement l’affichage des couleurs sur une LED RVB 5mm à cathode commune (- commun)
Ressources utiles associées à ce programme :
- Comprendre la génération d’impulsion à largeur modulée (ou PWM): Comment l’instruction simule une sortie analogique en utilisant la modulation de largeur d’impulsion (ou PWM).
2. Informations techniques : la LED multicolore RVB (ou RGB)
- Une LED RVB pour Rouge-Vert-Bleu (ou RGB pour Red Green Blue), n’est autre qu’un ensemble de 3 LEDs couleurs rassemblées dans un même boitier : si vous savez utiliser une LED, alors vous saurez utiliser une LED RVB !
- Une LED RGB aura donc 4 broches : une commune à l’ensemble des LEDs et une pour chaque LED de couleur. La broche commune pourra, selon les modèles, être le + (anode commune) ou le – (cathode commune)
- Pour obtenir les couleurs unitaires, il suffira d’allumer la LED de la couleur voulue.
- Pour obtenir toutes les variétés de couleurs, on va mixer la proportion de couleur de chaque LED à l’aide d’une impulsion dite PWM, qui aura pour effet de fixer la proportion de chaque couleur :
- 100% des 3 couleurs donnera du BLANC
- 100% de rouge et 100% de vert donnera du JAUNE
- 100% de rouge et 100% de bleu donnera du VIOLET
- Le brochage type d’une LED RGB est le suivant (la « patte » la plus longue est la broche commune, l’anode ou la cathode selon le modèle) :

3. Matériel Nécessaire
3.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.

3.2 Le matériel suivant pour réaliser le montage associé
- une plaque d’essai pour montage sans soudures,

- des straps,

- une LED RGB 5mm à cathode commune,

- 3 résistances 1/4w de 200 Ohms environ,



4. Instructions de montage
On connecte :
- la cathode commune au 0V
- la broche R de la LED RGB en série avec une résistance à une broche numérique de la carte Arduino
- la broche G de la LED RGB en série avec une résistance à une broche numérique de la carte Arduino
- la broche B de la LED RGB en série avec une résistance à une broche numérique de la carte Arduino
5. Le schéma théorique du montage
Le schéma théorique du montage (cliquer pour agrandir)
6. Le circuit du montage
Le schéma du montage à réaliser (cliquer pour agrandir)
7. Explication du programme
- Les 3 broches utilisées sont configurées en sortie
- On teste les couleurs de base puis les mélanges de base
- on teste enfin les variations de couleurs
- Sympa !
8. Mise en oeuvre du programme
8.1 Préparation du montage et programmation de la carte Arduino :
- Commencer par réaliser le montage indiqué sur plaque d’expérimentation
- Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle
8.2 Fonctionnement
- Réaliser le montage, programmer, enjoy !
9. Le programme complet en langage Arduino
A copier/coller directement dans l’éditeur Arduino
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr
// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 22/2/2012.
// ——- Licence du code de ce programme —–
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License,
// or any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// //////////////////// PRESENTATION DU PROGRAMME ////////////////////
// ——– Que fait ce programme ? ———
/* Ce programme teste simplement l’affichage des couleurs
sur une LED RVB 5mm à cathode commune (- commun)
La RVB dispose de 4 broches :
* une broche de 0V
* une broche de commande du ROUGE
* une broche de commande du VERT
* une broche de commande du BLEU
Chaque broche peut recevoir une impulsion PWM (0-255) pour doser l’intensité de chacune des couleurs.
*/
// — Fonctionnalités utilisées —
// ——– Circuit à réaliser ———
// Broche 3 : La broche Rouge de la LED RGB
// Broche 5 : La broche Vert de la LED RGB
// Broche 6 : La broche Bleu de la LED RGB
// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…
// — Déclaration des constantes —
// — Inclusion des librairies —
// — Déclaration des constantes utiles —
const int R=1;
const int V=1;
const int B=1;
// — Déclaration des constantes des broches E/S numériques —
const int ledRouge=3; // Constante pour la broche 3
const int ledVert=5; // Constante pour la broche 5
const int ledBleu=6; // Constante pour la broche 6
// — Déclaration des constantes des broches analogiques —
//const int Voie[6]={0,1,2,3,4,5}; //declaration constante de broche analogique
// — Déclaration des variables globales —
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
// ////////////////////////// 2. FONCTION SETUP = Code d’initialisation //////////////////////////
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme
void setup() { // debut de la fonction setup()
// — ici instructions à exécuter 1 seule fois au démarrage du programme —
// ——- Initialisation fonctionnalités utilisées ——-
// ——- Broches en sorties numériques ——-
pinMode (ledVert,OUTPUT); // Broche ledVert configurée en sortie
pinMode (ledRouge,OUTPUT); // Broche ledRouge configurée en sortie
pinMode (ledBleu,OUTPUT); // Broche ledBleu configurée en sortie
// ——- Broches en entrées numériques ——-
// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-
// ——- Initialisation des variables utilisées ——-
// ——- Codes d’initialisation utile ——-
} // fin de la fonction setup()
// ********************************************************************************
////////////////////////////////// 3. FONCTION LOOP = Boucle sans fin = coeur du programme //////////////////
// la fonction loop() s’exécute sans fin en boucle aussi longtemps que l’Arduino est sous tension
void loop(){ // debut de la fonction loop()
//—- vert —
digitalWrite(ledVert,HIGH); // allume la couleur voulue
delay(1000); // pause
digitalWrite(ledVert,LOW); // éteint la couleur voulue
delay(1000); // pause
//—- rouge —
digitalWrite(ledRouge,HIGH); // allume la couleur voulue
delay(1000); // pause
digitalWrite(ledRouge,LOW); // éteint la couleur voulue
delay(1000); // pause
//—- bleu —
digitalWrite(ledBleu,HIGH); // allume la couleur voulue
delay(1000); // pause
digitalWrite(ledBleu,LOW); // éteint la couleur voulue
delay(1000); // pause
//—– test des couleurs au format RVB —-
//—- violet —
ledRVB(R,0,B); // allume R ouge et Bleu => violet
delay(1000); // pause
ledRVB(0,0,0); // éteint toutes les couleurs
delay(1000); // pause
//—- jaune —
ledRVB(R,V,0); // allume R ouge et Vert => jaune
delay(1000); // pause
ledRVB(0,0,0); // éteint toutes les couleurs
delay(1000); // pause
//—- bleu clair —
ledRVB(0,V,B); // allume Vert et Bleu => bleu clair
delay(1000); // pause
ledRVB(0,0,0); // éteint toutes les couleurs
delay(1000); // pause
//—- blanc —
ledRVB(R,V,B); // allume Rouge Vert et Bleu => blanc
delay(1000); // pause
ledRVB(0,0,0); // éteint toutes les couleurs
delay(1000); // pause
//—– variation de couleur
// variation de rouge
for (int i=0; i<=255; i++) { // défile valeur 0 à 255
ledRVBpwm(i,0,0); // génère impulsion largeur voulue pour la couleur
delay(10); //pause
}
//ledRVB(0,0,0); // éteint toutes les couleurs
// variation de bleu – rouge dégressif
for (int i=0; i<=255; i++) { // défile valeur 0 à 255
ledRVBpwm(255–i,0,i); // génère impulsion largeur voulue pour la couleur
delay(10); //pause
}
//ledRVB(0,0,0); // éteint toutes les couleurs
// variation de vert – bleu dégressif
for (int i=0; i<=255; i++) { // défile valeur 0 à 255
ledRVBpwm(0,i,255–i); // génère impulsion largeur voulue pour la couleur
delay(10); //pause
}
// variation de jaune
for (int i=0; i<=255; i++) { // défile valeur 0 à 255
ledRVBpwm(i,255,0); // génère impulsion largeur voulue pour la couleur
delay(10); //pause
}
//etc…
ledRVB(0,0,0); // éteint toutes les couleurs
delay(1000);
//while(1); // stop loop
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////
// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////
//—- fonction pour combiner couleurs ON/OFF —-
void ledRVB(int Rouge, int Vert, int Bleu) {
if (Rouge==1) digitalWrite(ledRouge,HIGH); // allume couleur
if (Rouge==0) digitalWrite(ledRouge,LOW); // éteint couleur
if (Vert==1) digitalWrite(ledVert,HIGH); // allume couleur
if (Vert==0) digitalWrite(ledVert,LOW); // éteint couleur
if (Bleu==1) digitalWrite(ledBleu,HIGH); // allume couleur
if (Bleu==0) digitalWrite(ledBleu,LOW); // éteint couleur
}
//—- fonction pour variation progressive des couleurs —-
void ledRVBpwm(int pwmRouge, int pwmVert, int pwmBleu) { // reçoit valeur 0-255 par couleur
//— attention – avec une LED RGB anode commune : la LED s’allume sur niveau BAS !
analogWrite(ledRouge, pwmRouge); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut
analogWrite(ledVert, pwmVert); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut
analogWrite(ledBleu, pwmBleu); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut
}
// ////////////////////////// Fin du programme ////////////////////
Articles similaires:
- Test d’une LED couleur RVB à anode commune
- Test d’un ruban de LED colorées RVB
- http://web.archive.org/web/20210804223007/http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.TechniqueCompsantsLEDRGB
- Afficher les chiffres 0 à 9 sur un digit à cathode commune
- Tester les segments d’un digit à cathode commune
Articles Liés
- Test d'une LED couleur RVB à anode commune
Les LED RVB à anode commune sont un type de LED qui offre une variété…
- Tester les segments d'un digit à cathode commune
Les segments d'un digit à cathode commune sont une partie essentielle des systèmes électroniques. Ils…
- Faire clignoter une LED
Le clignotement d'une LED est un moyen simple et efficace pour ajouter une touche de…