Les jeux de lumières sur 8 LEDs sont une forme de divertissement qui a gagné en popularité ces dernières années. Les jeux de lumières sont une forme de divertissement qui combine la technologie et la créativité pour créer des spectacles visuels uniques et captivants. Les jeux de lumières sur 8 LEDs sont une forme de divertissement qui offre une variété de possibilités créatives et qui peut être utilisée pour créer des spectacles visuels à couper le souffle. Dans cet article, nous allons examiner les différentes façons dont les jeux de lumières sur 8 LEDs peuvent être utilisés pour créer des spectacles visuels uniques et captivants.
Jeux de lumières sur 8 LEDs
(:vimeo 🙂
1. Présentation
Ce programme réalise un affichage de « jeux de lumières » sur 8 LEDs : juste pour s’amuser et apprendre à manipuler les broches en sortie.
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,
- 8 LEDs rouge 5mm,
- 8 résistances 1/4w de 270 Ohms,
3. Instructions de montage
- Connecter sur la broche 4 (configurée en sortie) une LED rouge et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 5 (configurée en sortie) une LED rouge et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 6 (configurée en sortie) une LED rouge et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 7 (configurée en sortie) une LED rouge et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 8 (configurée en sortie) une LED verte et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 9 (configurée en sortie) une LED verte et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 10 (configurée en sortie) une LED verte et sa résistance 270 en série connectée au 0V
- Connecter sur la broche 11 (configurée en sortie) une LED verte et sa résistance 270 en série connectée au 0V
4. Le schéma théorique du montage
Le schéma théorique du montage
5. Le circuit du montage
Le schéma du montage à réaliser
6. Explication du programme
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.
Le déroulement du programme
7. Au niveau de la partie déclarative :
Déclaration des constantes de broches
- Déclaration des constantes pour les broches utilisées dans le programme : on déclare ici un tableau de constantes dont chaque valeur correspond aux broches utilisées.
Il est pratique d’utiliser un tableau dès lors que l’on va utiliser une action répétée sur plusieurs broches. Chaque broche sera ainsi accessible à l’aide de l’index du tableau, avec l’index 0 pour la première valeur. Un truc de programmation qui vous fera écrire des programmes propres.
const int LED[8]={4,5,6,7,8,9,10,11}; // déclare un tableau de 8 constantes de broches
// la broche 4 correspond au bit de poids faible (index 0 du tableau)
// la broche 11 correspond au bit de poids fort (index 8 du tableau)
Déclaration des variables globales
- Déclaration des variables globales du programmes : on déclare une variable pour la vitesse.
8. Au niveau de la fonction d’initialisation setup( ) :
configuration des broches utilisées :
- Configuration des broches en sortie : on met les 8 broches en sortie à l’aide d’une boucle for :
// met les 8 broches en sortie
for (int i=0; i<=7; i++) { // boucle de défilement des 8 broches
pinMode(LED[i], OUTPUT); //met la broche en sortie
}
9. Au niveau de la boucle principale, la fonction loop ( ) :
- Au sein d’une boucle principale, on réalise un premier jeu de lumière en utilisant une succession d’instructions digitalWrite. Le code est assez lourd. Remarquer l’utilisation de la virgule pour séparer les instructions sur la même ligne.
- On utilise également une fonction dédiée à laquelle va être transmise une valeur binaire 8 bits correspondant à l’état voulu pour les LEDs. La programmation du jeu de lumière devient alors beaucoup plus simple et lisible.
- Le programme recommence en boucle les instructions de la fonction loop( ).
Se reporter aux commentaires présents dans le programme pour plus de détails.
10. Autres fonctions
- On crée également une fonction dédiée à laquelle va être transmise une valeur binaire 8 bits correspondant à l’éLa programmation du jeu de lumière devient alors beaucoup plus simple et lisible. tat voulu pour les LEDs. Cette fonction reçoit une valeur de type byte et ne renvoie rien (void).
11. Mise en oeuvre du programme
11.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
11.2 Fonctionnement
- Les LEDs affichent les jeux de lumière programmés.
12. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// Copyright X. HINAULT – Créé le 09/05/2010
// www.mon-club-elec.fr
// Code sous licence GNU GPL :
// 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/>.
//
// — Que fait ce programme ? —
/* « Jeux de lumière » sur 8 LEDs. */
// — Fonctionnalités utilisées —
// — Circuit à réaliser —
// Connecter sur la broche 4 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 5 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 6 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 7 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 8 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 9 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 10 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
// Connecter sur la broche 11 (configurée en sortie) une LED et sa résistance 270 Ohms en série connectée au 0V
//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables…
// — Inclusion des librairies utilisées —
// — Déclaration des constantes —
// — constantes des broches —
const int LED[8]={4,5,6,7,8,9,10,11}; // déclare un tableau de 8 constantes de broches
// la broche 4 correspond à la LED[0], 5 à LED[1], ..
// — Déclaration des variables globales —
int vitesse=100; // variable de vitesse entre chaque affichage des LEDs
// — Déclaration des objets utiles pour les fonctionnalités utilisées —
//**************** 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 au démarrage —
// ——- Broches en sortie ——-
// met les 8 broches en sortie
for (int i=0; i<=7; i++) { // boucle de défilement des 8 broches
pinMode(LED[i], OUTPUT); //met la broche en sortie
digitalWrite(LED[i], LOW); // met la broche à 0V (LED éteinte) pour démarrer
}
} // fin de la fonction setup()
// ********************************************************************************
//*************** 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()
//——– méthode basique ———–
// LED seule se déplace
for (int j=0; j<10; j++) { //boucle de répétition x 10
digitalWrite (LED[0],1), digitalWrite (LED[1],0), digitalWrite (LED[2],0),digitalWrite (LED[3],0);
digitalWrite (LED[4],0),digitalWrite (LED[5],0),digitalWrite (LED[6],0),digitalWrite (LED[7],0);
delay (vitesse);
digitalWrite (LED[0],0), digitalWrite (LED[1],1), digitalWrite (LED[2],0),digitalWrite (LED[3],0);
digitalWrite (LED[4],0),digitalWrite (LED[5],0),digitalWrite (LED[6],0),digitalWrite (LED[7],0);
delay (vitesse);
digitalWrite (LED[0],0), digitalWrite (LED[1],0), digitalWrite (LED[2],1),digitalWrite (LED[3],0);
digitalWrite (LED[4],0),digitalWrite (LED[5],0),digitalWrite (LED[6],0),digitalWrite (LED[7],0);
delay (vitesse);
digitalWrite (LED[0],0), digitalWrite (LED[1],0), digitalWrite (LED[2],0),digitalWrite (LED[3],1);
digitalWrite (LED[4],0),digitalWrite (LED[5],0),digitalWrite (LED[6],0),digitalWrite (LED[7],0);
delay (vitesse);
digitalWrite (LED[0],0), digitalWrite (LED[1],0), digitalWrite (LED[2],0),digitalWrite (LED[3],0);
digitalWrite (LED[4],1),digitalWrite (LED[5],0),digitalWrite (LED[6],0),digitalWrite (LED[7],0);
delay (vitesse);
digitalWrite (LED[0],0), digitalWrite (LED[1],0), digitalWrite (LED[2],0),digitalWrite (LED[3],0);
digitalWrite (LED[4],0),digitalWrite (LED[5],1),digitalWrite (LED[6],0),digitalWrite (LED[7],0);
delay (vitesse);
digitalWrite (LED[0],0), digitalWrite (LED[1],0), digitalWrite (LED[2],0),digitalWrite (LED[3],0);
digitalWrite (LED[4],0),digitalWrite (LED[5],0),digitalWrite (LED[6],1),digitalWrite (LED[7],0);
delay (vitesse);
digitalWrite (LED[0],0), digitalWrite (LED[1],0), digitalWrite (LED[2],0),digitalWrite (LED[3],0);
digitalWrite (LED[4],0),digitalWrite (LED[5],0),digitalWrite (LED[6],0),digitalWrite (LED[7],1);
delay (vitesse);
} // fin boucle for x10
allumeLED(B00000000);
delay(1000);
//———– méthode évoluée – code plus propre —————
// effet rideau
for (int j=0; j<10; j++) { //boucle de répétition x 10
allumeLED(B10000001); // appelle la fonction qui met les LEDs dans l’état des bits
allumeLED(B11000011);
allumeLED(B11100111);
allumeLED(B11111111);
allumeLED(B11100111);
allumeLED(B11000011);
allumeLED(B10000001);
} // fin boucle for x10
allumeLED(B00000000);
delay(1000);
// effet K2000
for (int j=0; j<10; j++) { //boucle de répétition x 10
allumeLED(B11100000); // appelle la fonction qui met les LEDs dans l’état des bits
allumeLED(B01110000);
allumeLED(B00111000);
allumeLED(B00011100);
allumeLED(B00001110);
allumeLED(B00000111);
allumeLED(B00001110);
allumeLED(B00011100);
allumeLED(B00111000);
allumeLED(B01110000);
} // fin boucle for x10
allumeLED(B00000000);
delay(1000);
} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
// création d’une fonction qui reçoit une valeur de type byte et ne renvoie aucune valeur
void allumeLED(byte valeur) { // fonction pour allumer/éteindre les LEDs voulue en fonction valeur 8 bits reçue
for (int i=0; i<=7; i++) {
digitalWrite(LED[i],bitRead(valeur,i)); // met la broche LED[i] dans l’état du bit de rang i de la variable
}
delay(vitesse); //pause
} // fin de la fonction
// — Fin programme —
