Le contrôle d’un ruban à LEDs RGB est une tâche complexe qui peut être simplifiée grâce à l’utilisation d’une interface Processing. Processing est un langage de programmation open source qui permet aux utilisateurs de créer des programmes graphiques interactifs. Dans cet article, nous allons examiner comment utiliser Processing pour contrôler un ruban à LEDs RGB et comment cela peut être utile pour les projets de bricolage et de développement. Nous verrons également comment le ruban à LEDs RGB peut être utilisé pour créer des effets visuels intéressants et comment il peut être intégré à d’autres projets.
Contrôle d’un ruban à LEDs RGB depuis une interface Processing.
(cliquer sur l’image pour agrandir)
1. Présentation
- Ce programme permet de contrôler à la souris depuis le PC les couleurs d’un ruban à LEDs RVB ou RGB : c’est très visuel et sympa à faire.
- Côté PC, on utilise une interface Processing simple utilisant trois contrôles réglables (sliders) de la librairie graphique controlP5. A chaque modification du slider, une chaine de caractères sous la forme « Rouge127 » suivi d’un saut de ligne est envoyé sur le port série.
- La carte Arduino reçoit sur le port Série les valeurs respectives pour les couleurs Rouge Vert Bleu à utiliser pour le ruban RGB.
- Le ruban RGB est directement controlé via 3 broches PWM via un simple CI ULN2803 pour assurer l’amplification de puissance et l’adaptation en tension.
Ce programme utilise les fonctionnalités suivantes :
- Utilise la connexion série vers le PC
- Utilise un ruban à Leds RGB
Ressources utiles associées à ce programme :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
- Ruban à LEDs RGB
- la documentation de l’instruction analogWrite()
- la page : Comprendre les impulsions PWM
- Amplification de puissance et masse commune
- Le circuit ULN 2803 octuple driver de puissance
2. Informations techniques concernant le ruban LEDs RGB
- Le ruban à LEDs RVB dispose de 4 broches :
- une broche d’alimentation 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é
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,


- un ruban à LEDs colorées RVB (pas un monochrome !) et fonctionnant en 12V (c’est important ici).

4. Instructions de montage
- La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
- Broche 3 : La broche Vert du ruban LED RGB via ULN 2803 ou équiv
- Broche 5 : La broche Rouge du ruban LED RGB via ULN 2803 ou équiv
- Broche 6 : La broche Bleu du ruban LED RGB via ULN 2803 ou équiv
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
- La carte Arduino reçoit sur le port Série les valeurs respectives pour les couleurs Rouge Vert Bleu à utiliser pour le ruban RGB.
- Une impulsion PWM (ou MLI) de largeur voulue est générée en conséquence sur les broches de couleurs.
- Le ruban RGB est directement controlé via 3 broches PWM via un simple CI ULN2803 pour assurer l’amplification de puissance et l’adaptation en tension.
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
- Lancer l’interface Processing et faire varier les Sliders : les couleurs du ruban RVB varient en conséquence.
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 : 15/3/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 ? ———
/* La carte Arduino reçoit sur le port Série les valeurs respectives
pour les couleurs Rouge Vert Bleu à utiliser pour le ruban RGB.
Le ruban RGB est directement controlé via 3 broches PWM via un simple
CI ULN2803 pour assurer l’amplification de puissance et l’adaptation en tension. */
// — Fonctionnalités utilisées —
// Utilise la connexion série vers le PC
// Utilise / fonctionne avec une interface Processing coté PC
// Utilise un ruban à LED RGB
// ——– Circuit à réaliser ———
// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
// Broche 3 : La broche Vert du ruban LED RGB via ULN 2803 ou équiv
// Broche 5 : La broche Rouge du ruban LED RGB via ULN 2803 ou équiv
// Broche 6 : La broche Bleu du ruban LED RGB via ULN 2803 ou équiv
// /////////////////////////////// 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 —
int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre reçu sur le port Série
String chaineReception=« »; // déclare un objet String vide pour reception chaine
int impulsionRouge=0; // variable pour impulsion ROuge
int impulsionVert=0; // variable pour impulsion ROuge
int impulsionBleu=0; // variable pour impulsion ROuge
// — 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 ——-
Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission
// ——- 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 —
//—- code type réception chaine sur le port série —
while (Serial.available()>0) { // tant qu’un octet en réception
octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable
if (octetReception==10) { // si Octet reçu est le saut de ligne
Serial.println (« Chaine recue= »+chaineReception); // affiche la chaine recue
chaineReception.trim(); // enlève espaces
analyseChaine(chaineReception); // appelle la fonction d’analyse de la chaine en réception
break; // sort de la boucle while
}
else { // si le caractère reçu n’est pas un saut de ligne
chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
}
} // fin tant que octet réception
//—– une fois que le saut de ligne est reçu, on sort du While et on se positionne ici
chaineReception=« »; //RAZ le String de réception
} // 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 d’analyse de la chaine reçue sur le port série —-
void analyseChaine(String chaineRecue) { // fonction d’analyse de la chaine recue
//— variables locales
int valeur=0; // variable utile
String chaineTest=« »; // objet STring pour analyse chaine recue
// >>>>>>>>>>>>>>>>>>>>>>>>>>>> si débute par Rouge <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if (chaineRecue.startsWith(« Rouge »)) { // si la chaine débute par « chaine »
chaineTest=chaineRecue.substring(String(« Rouge »).length(),chaineRecue.length()); // extraction des derniers caractères – le 1er est à index=0
Serial.println(chaineTest); // debug
// récupération du nombre à partir chaine caractère
impulsionRouge=stringToLong(chaineTest); // récupère valeur numérique chaine
impulsionRouge=constrain(impulsionRouge,0,255); // oblige valeur entre 0 et 255
Serial.print (« Rouge = « ), Serial.println(impulsionRouge); //debug
ledRVBpwm(impulsionRouge,impulsionVert,impulsionBleu); // génère impulsion largeur voulue pour les couleurs
} // fin débute avec « Rouge »
// >>>>>>>>>>>>>>>>>>>>>> si débute par Vert <<<<<<<<<<<<<<<<<<<<<<<<<<<<<
if (chaineRecue.startsWith(« Vert »)) { // si la chaine débute par « chaine »
chaineTest=chaineRecue.substring(String(« Vert »).length(),chaineRecue.length()); // extraction des derniers caractères – le 1er est à index=0
Serial.println(chaineTest); // debug
// récupération du nombre à partir chaine caractère
impulsionVert=stringToLong(chaineTest); // récupère valeur numérique chaine
impulsionVert=constrain(impulsionVert,0,255); // oblige valeur entre 0 et 255
Serial.print (« Vert = « ), Serial.println(impulsionVert); //debug
ledRVBpwm(impulsionRouge,impulsionVert,impulsionBleu); // génère impulsion largeur voulue pour les couleurs
} // fin débute avec « Vert »
// >>>>>>>>>>>>>>>>>>>>>>>>>>> si débute par Rouge <<<<<<<<<<<<<<<<<<<<<<<<<
if (chaineRecue.startsWith(« Bleu »)) { // si la chaine débute par « chaine »
chaineTest=chaineRecue.substring(String(« Bleu »).length(),chaineRecue.length()); // extraction des derniers caractères – le 1er est à index=0
Serial.println(chaineTest); // debug
// récupération du nombre à partir chaine caractère
impulsionBleu=stringToLong(chaineTest); // récupère valeur numérique chaine
impulsionBleu=constrain(impulsionBleu,0,255); // oblige valeur entre 0 et 255
Serial.print (« Bleu = « ), Serial.println(impulsionBleu); //debug
ledRVBpwm(impulsionRouge,impulsionVert,impulsionBleu); // génère impulsion largeur voulue pour la couleur
} // fin débute avec « Rouge »
} // fin fonction analyse chaine
// ———- fonction de conversion d’un String numérique en long
long stringToLong(String chaineLong) { // fonction conversion valeur numérique String en int
long nombreLong=0; // variable locale
int valeurInt=0; // variable locale
for (int i=0; i<chaineLong.length(); i++) { // défile caractères de la chaine numérique
valeurInt=chaineLong.charAt(i); // extrait le caractère ASCII à la position voulue – index 0 est le 1er caractère
valeurInt=valeurInt–48; // obtient la valeur décimale à partir de la valeur ASCII
// Serial.println (valeurInt); // debug
if (valeurInt>=0 && valeurInt<=9) { // si caractère est entre 0 et 9
nombreLong=(nombreLong*10)+valeurInt;
} // fin si caractère est entre 0 et 9
} // fin for défile caractères
return (nombreLong); // renvoie valeur numérique
} // fin stringToLong
//—- fonction pour variation progressive des couleurs sur ruban Leds RGB —-
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 fonction RGB pwm
// ////////////////////////// Fin du programme ////////////////////
10. Le programme Processing
10.1 Description
- 3 réglages graphiques permettent de régler les valeurs de la largeur d’impulsion utilisée avec le rouge, le vert et le bleu.
- pour chaque couleur, une valeur entre 0 et 255 est envoyée sur le port série.
10.2 Ressources utiles
- la librairie controlP5
10.3 Le programme complet en langage Processing
A copier/coller directement dans l’éditeur Processing
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT – Mars 2011 – tous droits réservés
/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise la librairie GUI controlP5
// Utilise un/des réglage(s) linéaire(s) (Slider)
// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX
// inclusion des librairies utilisées
import processing.serial.*; // importe la librairie série processing
import controlP5.*; // importe la librairie GUI controlP5
// cette librairie doit être présente dans le répertoire /libraries du répertoire Processing
// voir ici : http://www.sojamo.de/libraries/controlP5/
// déclaration objets
// — port Série —
Serial myPort; // Création objet désignant le port série
ControlP5 controlP5; // déclare un objet principal de la librairie GUI controlP5
Slider sRouge, sVert, sBleu; // déclare un/ des objet Slider
// déclaration variables globales
//—— déclaration des variables de couleur utiles —-
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);
// XXXXXXXXXXXXXXXXXXXXXX Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX
void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage
// —- initialisation paramètres graphiques utilisés
colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
fill(0,0,255); // couleur remplissage RGB
stroke (0,0,0); // couleur pourtour RGB
rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
//strokeWeight(0); // largeur pourtour
frameRate(15);// Images par seconde
// — initialisation fenêtre de base —
size(220, 400); // ouvre une fenêtre xpixels x ypixels
background(0,0,0); // couleur fond fenetre
// — initialisation des objets et fonctionnalités utilisées —
//————- initialisation port série —-
println(Serial.list()); // affiche dans la console la liste des ports séries
// Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec Serial.list()[index]
myPort = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série
//myPort = new Serial(this, « /dev/ttyUSB0 », 115200); // Initialise une nouvelle instance du port Série
myPort.bufferUntil(‘\n‘); // attendre arrivée d’un saut de ligne pour générer évènement série
//======== Initialisation Objets GUI ControlP5 =========
controlP5 = new ControlP5(this); // initialise l’objet principal de la librairie GUI controlP5
// typeObjet nomObjet=controlP5.addObjet(paramètres); // pour info : déclaration / initialisation possible en 1 ligne
// Textfield field = controlP5.addTextfield(« myWindowTextfield »,70,130,100,20); // exemple
//======== Initialisation Objets Sliders =========
//———— slider Rouge —————-
// addSlider(theName, theMin, theMax, theDefaultValue, theX, theY, theW, theH)
sRouge=controlP5.addSlider(« sRouge »,0,255,0,10,10,50,380); // ajoute un Slider au ControlP5
//s1 = (Slider)controlP5.controller(« MonSlider1 »); // initialise l’objet Slider déclaré
// méthodes propres à l’objet Slider
sRouge.setNumberOfTickMarks(256); // fixe le nombre crans – n+1 pour n valeurs
//s1.setNumberOfTickMarks((int(s1.max())+1); // fixe le nombre crans – n+1 pour n valeurs
sRouge.showTickMarks(false); // affichage des repères
sRouge.setSliderMode(Slider.FIX); // fonctionnement du slider FLEXIBLE ou FIX
// méthodes communes à tous les controles (objet Controller)
sRouge.setLabelVisible(true); // affichage des labels
sRouge.setLabel(« ROUGE »); // fixe label objet
sRouge.setDecimalPrecision(0); // fixe la précision
sRouge.setColorActive(rouge); // fixe la couleur active
//sRouge.setColorBackground(color(255,255,0)); // fixe couleur fond
sRouge.setColorForeground(rouge); // fixe couleur avant
//sRouge.setArrayValue(new float[] {100,255} ); // fixe les valeurs min/max du Slider ?
sRouge.setColorCaptionLabel(blanc); // fixe couleur Label
sRouge.setColorValueLabel(noir); // fixe la couleur valeur
//———— slider VERT —————-
// addSlider(theName, theMin, theMax, theDefaultValue, theX, theY, theW, theH)
sVert=controlP5.addSlider(« sVert »,0,255,0,80,10,50,380); // ajoute un Slider au ControlP5
//s1 = (Slider)controlP5.controller(« MonSlider1 »); // initialise l’objet Slider déclaré
// méthodes propres à l’objet Slider
sVert.setNumberOfTickMarks(256); // fixe le nombre crans – n+1 pour n valeurs
//s1.setNumberOfTickMarks((int(s1.max())+1); // fixe le nombre crans – n+1 pour n valeurs
sVert.showTickMarks(false); // affichage des repères
sVert.setSliderMode(Slider.FIX); // fonctionnement du slider FLEXIBLE ou FIX
// méthodes communes à tous les controles (objet Controller)
sVert.setLabelVisible(true); // affichage des labels
sVert.setLabel(« VERT »); // fixe label objet
sVert.setDecimalPrecision(0); // fixe la précision
sVert.setColorActive(vert); // fixe la couleur active
//sRouge.setColorBackground(color(255,255,0)); // fixe couleur fond
sVert.setColorForeground(vert); // fixe couleur avant
//sRouge.setArrayValue(new float[] {100,255} ); // fixe les valeurs min/max du Slider ?
sVert.setColorCaptionLabel(blanc); // fixe couleur Label
sVert.setColorValueLabel(noir); // fixe la couleur valeur
//———— slider BLEU —————-
// addSlider(theName, theMin, theMax, theDefaultValue, theX, theY, theW, theH)
sBleu=controlP5.addSlider(« sBleu »,0,255,0,150,10,50,380); // ajoute un Slider au ControlP5
//s1 = (Slider)controlP5.controller(« MonSlider1 »); // initialise l’objet Slider déclaré
// méthodes propres à l’objet Slider
sBleu.setNumberOfTickMarks(256); // fixe le nombre crans – n+1 pour n valeurs
//s1.setNumberOfTickMarks((int(s1.max())+1); // fixe le nombre crans – n+1 pour n valeurs
sBleu.showTickMarks(false); // affichage des repères
sBleu.setSliderMode(Slider.FIX); // fonctionnement du slider FLEXIBLE ou FIX
// méthodes communes à tous les controles (objet Controller)
sBleu.setLabelVisible(true); // affichage des labels
sBleu.setLabel(« BLEU »); // fixe label objet
sBleu.setDecimalPrecision(0); // fixe la précision
sBleu.setColorActive(bleu); // fixe la couleur active
//sRouge.setColorBackground(color(255,255,0)); // fixe couleur fond
sBleu.setColorForeground(bleu); // fixe couleur avant
//sRouge.setArrayValue(new float[] {100,255} ); // fixe les valeurs min/max du Slider ?
sBleu.setColorCaptionLabel(blanc); // fixe couleur Label
sBleu.setColorValueLabel(noir); // fixe la couleur valeur
} // fin fonction Setup
// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX
void draw() { // fonction exécutée en boucle
} // fin de la fonction draw()
// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX
// Gestion des évènements des objets GUI controlP5 —-
//—— fonction gestion globale des évènements GUI controlP5
public void controlEvent(ControlEvent theEvent) {
//println(theEvent.controller().name());// affiche le nom de l’évènement
}
// —— gestion évènement Slider ——
void sRouge(float valeur) { // fonction évènement Slider de meme nom – reçoit la valeur
println(« Evènement Slider Rouge avec valeur = « +valeur);
myPort.write(« Rouge »+int(valeur)+« \n« ); // envoie le texte Rouge + la valeur suivie d’un saut de ligne sur le port Série
}
// —— gestion évènement Slider ——
void sVert(float valeur) { // fonction évènement Slider de meme nom – reçoit la valeur
println(« Evènement Slider Vert avec valeur = « +valeur);
myPort.write(« Vert »+int(valeur)+« \n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série
}
// —— gestion évènement Slider ——
void sBleu(float valeur) { // fonction évènement Slider de meme nom – reçoit la valeur
println(« Evènement Slider Vert avec valeur = « +valeur);
myPort.write(« Bleu »+int(valeur)+« \n« ); // envoie la valeur suivie d’un saut de ligne sur le port Série
}
//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX
Articles Liés
- Mesure analogique à distance (télémétrie) multivoies à partir d'une carte Arduino "serveur" via deux interfaces Processing Client/Serveur sur 2 PC connectés en réseau wifi.
La télémétrie est une technologie qui permet de mesurer des données à distance. Elle est…
- Mesure d'une intensité à l'aide du capteur de courant +/-5A ACS714 (affichage graphique Processing)
La mesure d'une intensité est une tâche importante pour de nombreuses applications industrielles et domestiques.…
- Ethernet en mode serveur : Serveur réseau de datalogging avec stockage dans une SD-Card et accès distant dans une interface Processing
L'Ethernet en mode serveur est une technologie révolutionnaire qui permet aux utilisateurs de créer un…