View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Test d'un ruban de LED colorées RVB

Par X. HINAULT - Page créée le : 23/2/2011.

1.  Présentation

Ce programme teste l'affichage des couleurs sur un ruban à LED colorées RVB (ou ruban à LED RGB, c'est pareil). Les LEDs sont alimentées en 12V : on utilisera donc un ULN 2803 (octuple amplificateur inverseur 500mA) en guise d'interface de puissance. Ce CI a l'avantage d'être très simple à utiliser et à simplifier le montage en évitant l'utilisation d'autres composants externes ( part la carte Arduino bien sûr).

Le ruban à LEDs RVB dispose de 4 broches :

  • une broche de 12V
  • une broche de commande du ROUGE (active sur 0V)
  • une broche de commande du VERT (active sur 0V)
  • une broche de commande du BLEU (active sur 0V)

Chaque broche peut recevoir une impulsion PWM (0-255) pour doser l'intensité de chacune des couleurs.

Noter que les broches RVB du ruban à LED sont actives sur 0V : comme on utilise un ULN2803 qui a pour effet d'inverser le niveau d'entrée, un niveau numérique HAUT donnera du 0V sur la broche LED

Un Ruban à LEDs RVB peut demander une intensité significative si il est long : vous devrez donc disposer d'une alimentation capable de fournir du 12V en au moins 2 Ampères pour être à l'aise... Une alimentation de PC fera l'affaire. Voir la page : Utiliser une alimentation de PC comme alim 5V/12V régulé

Voir également :

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

  • une plaque d'essai pour montage sans soudures,
  • des straps,
  • un ruban à LEDs colorées RVB (pas un monochrome !) et fonctionnant en 12V (c'est important ici).

Personnellement, j'utilise ici un ruban XanLite de 1m trouvé chez Leroy Merlin à 34€. Evidemment, vous n'avez pas besoin d'acheter la commande du ruban car c'est ce qu'on va faire ici avec une carte Arduino !

3.  Instructions de montage

Le ruban à LEDs RVB dispose de 4 broches :

  • une broche de 12V
  • une broche de commande du ROUGE (active sur 0V)
  • une broche de commande du VERT (active sur 0V)
  • une broche de commande du BLEU (active sur 0V)

On pourra souder un connecteur sur fils à 4 broches sur l'extrémité du ruban pour faciliter les connexions avec la plaque d'essai.

4.  Le schéma théorique du montage

Le schéma théorique du montage (cliquer pour agrandir)

5.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

  • On voit clairement ici que l'utilisation d'un bornier 4 broches sur fil couplé au CI ULN 2803 limite au minimum les composants externes et rend le montage vraiment simple ! Pas de résistances en plus, pas de transistors, pas de straps en vrac...
  • Noter également que si on alimente la carte Arduino en 12V, il suffit de récupérer le 12V sur la broche Vin...

Noter que les broches RVB du ruban à LED sont actives sur 0V : comme on utilise un ULN2803 qui a pour effet d'inverser le niveau d'entrée, un niveau numérique HAUT donnera du 0V sur la broche LED. Ainsi la programmation sera intuitive : pour allumer une couleur, on met la broche numérique au niveau HAUT !

6.  Explication du programme

6.1  Au niveau de la partie déclarative :

  • On renomme les broches utilisées
  • On déclare 3 constantes R,V et B valant 1.

6.2  Au niveau de la fonction d'initialisation setup( ) :

  • On met les 3 broches en sortie

6.3  Au niveau de la boucle principale, la fonction loop ( ) :

  • On teste tout d'abord l'allumage des couleurs simples
  • Puis on utilise une fonction pour allumer les couleurs au format RVB (1 ou 0 pour chaque couleur).
  • Enfin, on teste la variation lumineuse à l'aide d'une fonction utilisant la génération d'impulsion PWM sur chaque broche de couleur, à l'aide de l'instruction analogWrite()

7.  Mise en oeuvre du programme

7.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

7.2  Fonctionnement

  • Mettre sous tension et admirer les belles couleurs : c'est sympa !!

8.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


// --- Programme 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 : 23/2/2011.

// ------- 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 l'affichage des couleurs sur un ruban à LED colorées RVB.
Les LEDs sont alimentées en 12V : on utilisera donc un ULN 2803 en guise d'interface de puissance.  

Le ruban à LEDs RVB dispose de 4 broches :
* une broche de 12V
* 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.  

Noter que les broches RVB du ruban à LED sont actives sur 0V : comme on utilise un ULN2803 qui a pour effet d'inverser le niveau d'entrée, un niveau numérique HAUT donnera du 0V sur la broche LED
*/


// --- Fonctionnalités utilisées ---

// utilise la génération PWM

// -------- Circuit à réaliser ---------

// Broche 3 : La broche Vert du ruban LED RGB
// Broche 5 : La broche Rouge du ruban LED RGB
// Broche 6 : La broche Bleu du ruban 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 ledVert=3; // Constante pour la broche 3
const int ledRouge=5; // Constante pour la broche 5
const int ledBleu=6; // Constante pour la broche 6

// --- Déclaration des constantes des broches analogiques ---


// --- 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 -------  



} // 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()


// --- ici instructions à exécuter par le programme principal ---

//----- test simple des couleurs -----

//---- vert ---
digitalWrite(ledVert,HIGH); // allume la couleur voulue
delay(1000); // pause
digitalWrite(ledVert,LOW); // allume la couleur voulue
delay(1000); // pause

//---- rouge ---
digitalWrite(ledRouge,HIGH); // allume la couleur voulue
delay(1000); // pause
digitalWrite(ledRouge,LOW); // allume la couleur voulue
delay(1000); // pause

//---- bleu ---
digitalWrite(ledBleu,HIGH); // allume la couleur voulue
delay(1000); // pause
digitalWrite(ledBleu,LOW); // allume 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

 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 ////////////////////