next topic »

[on:]

Bonjour a tous
je vient a vous pour optenir de l'aide ou du moins le code pour un chenillard 8 leds
voila je voudrai savoir le code pour optenir un effet d'atténuement entre chaque leds
Voici mon code actuelle que faut t'il rejouter

const int LED[8]={0,1,2,3,4,5,6,7}; // 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=250; // 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, OUTPUT); //met la broche en sortie
  digitalWrite(LED, 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(300);

//----------- méthode évoluée - code plus propre ---------------

// effet rideau
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B00000000); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B10000001);   
  allumeLED(B11000011);       
  allumeLED(B11100111);       
  allumeLED(B11111111);       
  allumeLED(B11100111);       
  allumeLED(B11000011);       
  allumeLED(B10000001);   
  allumeLED(B00000000);     

} // fin boucle for x10

allumeLED(B00000000);
delay(300);

// 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(B00000110);       
  allumeLED(B00000011);       
  allumeLED(B00001110);       
  allumeLED(B00011100);       
  allumeLED(B00111000);       
  allumeLED(B01110000);
  allumeLED(B11100000); 


} // fin boucle for x10

allumeLED(B00000000);
delay(300);

// effet FLIPPERS
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B00000000); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B00011000);       
  allumeLED(B00111100);       
  allumeLED(B01111110);       
  allumeLED(B11111111);       
  allumeLED(B01111110);       
  allumeLED(B00111100);             
  allumeLED(B00011000);       
  allumeLED(B00000000);     
 
 
} // fin boucle for x10
 
allumeLED(B00000000);
delay(300);

// effet FLIPPERS 02
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B00010001); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B00100010);       
  allumeLED(B01000100);       
  allumeLED(B10001000);       
  allumeLED(B01000100);       
  allumeLED(B00100010);       
  allumeLED(B00010001);
 
} // fin boucle for x10

allumeLED(B00000000);
delay(300);
 
  // effet FLIPPERS 03
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B10000000); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B11000000);       
  allumeLED(B11100000);       
  allumeLED(B11110000);       
  allumeLED(B11111000);       
  allumeLED(B11111100);       
  allumeLED(B11111110);
  allumeLED(B11111111);
  allumeLED(B01111111);       
  allumeLED(B00111111);       
  allumeLED(B00011111);       
  allumeLED(B00001111);       
  allumeLED(B00000111);       
  allumeLED(B00000011);
  allumeLED(B00000001);
 
} // fin boucle for x10
 
} // 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,bitRead(valeur,i)); // met la broche LED dans l'état du bit de rang i de la variable
  }
  delay(vitesse); //pause

} // fin de la fonction

// --- Fin programme ---

Milles merci de votre aide

[Reply #1 on:]

milles merci
le code que tu ma transmit doit être placé ou exactement
a la place du void setup()actuelle ou je doit l'incerer jute apres???
merci a toi

[Reply #2 on:]

milles merci
le code que tu ma transmit doit être placé ou exactement
a la place du void setup()actuelle ou je doit l'incerer jute apres???
merci a toi

[Reply #3 on:]

donc cela devrai etre comme ceci:

for (count=0;count<12;count++) {
    pinMode(pinArray[count], OUTPUT);
 
// met les 8 broches en sortie
for (int i=0; i<=7; i++) { // boucle de défilement des 8 broches

  pinMode(LED, OUTPUT); //met la broche en sortie
  digitalWrite(LED, LOW); // met la broche à 0V (LED éteinte) pour démarrer

}
void loop() {
  for (count=0;count<11;count++) {
   digitalWrite(pinArray[count], HIGH);
   delay(timer);
   digitalWrite(pinArray[count + 1], HIGH);
   delay(timer);
   digitalWrite(pinArray[count], LOW);
   delay(timer*2);
  }
  for (count=11;count>0;count--) {
   digitalWrite(pinArray[count], HIGH);
   delay(timer);
   digitalWrite(pinArray[count - 1], HIGH);
   delay(timer);
   digitalWrite(pinArray[count], LOW);
   delay(timer*2);
  }
//-------- 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(300);

//----------- méthode évoluée - code plus propre ---------------

// effet rideau
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B00000000); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B10000001);   
  allumeLED(B11000011);       
  allumeLED(B11100111);       
  allumeLED(B11111111);       
  allumeLED(B11100111);       
  allumeLED(B11000011);       
  allumeLED(B10000001);   
  allumeLED(B00000000);     

} // fin boucle for x10

allumeLED(B00000000);
delay(300);

// 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(B00000110);       
  allumeLED(B00000011);       
  allumeLED(B00001110);       
  allumeLED(B00011100);       
  allumeLED(B00111000);       
  allumeLED(B01110000);
  allumeLED(B11100000); 


} // fin boucle for x10

allumeLED(B00000000);
delay(300);

// effet FLIPPERS
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B00000000); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B00011000);       
  allumeLED(B00111100);       
  allumeLED(B01111110);       
  allumeLED(B11111111);       
  allumeLED(B01111110);       
  allumeLED(B00111100);             
  allumeLED(B00011000);       
  allumeLED(B00000000);     
 
 
} // fin boucle for x10
 
allumeLED(B00000000);
delay(300);

// effet FLIPPERS 02
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B00010001); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B00100010);       
  allumeLED(B01000100);       
  allumeLED(B10001000);       
  allumeLED(B01000100);       
  allumeLED(B00100010);       
  allumeLED(B00010001);
 
} // fin boucle for x10

allumeLED(B00000000);
delay(300);
 
  // effet FLIPPERS 03
for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B10000000); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B11000000);       
  allumeLED(B11100000);       
  allumeLED(B11110000);       
  allumeLED(B11111000);       
  allumeLED(B11111100);       
  allumeLED(B11111110);
  allumeLED(B11111111);
  allumeLED(B01111111);       
  allumeLED(B00111111);       
  allumeLED(B00011111);       
  allumeLED(B00001111);       
  allumeLED(B00000111);       
  allumeLED(B00000011);
  allumeLED(B00000001);
 
} // fin boucle for x10
 
} // 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,bitRead(valeur,i)); // met la broche LED dans l'état du bit de rang i de la variable
  }
  delay(vitesse); //pause

} // fin de la fonction

// --- Fin programme ---

[Reply #4 on:]

Bonjour a tous je vient a vous pour solicité votre aide pour mon code actuelle
j'ai un code chenillard arduino 8 leds avec plusieurs effets différent par enchainement avec une intervalle de pause de quelques secondes entre chaque effet
mais je désirerai placer sur chaque effet un mode chaser en plus comme sur cette vidéo

je vous fourni mon code
avec qui j'espère une ame charitable sera le modifié avec ma demande
Milles merci de votre aide

[Reply #5 on:]

personne ne peu me donner cet petite aide aussi peu soit t'elle ????


Edit de Jean-François :  Pas de "up".... surtout deux heures après le premier post et de plus dans un doublon.

La prochaine je supprime complétement le deuxième sujet.

[Reply #6 on:]

Salut 
alors avec mes connaissances et (j'espère) sans dire de conneries :

tu reprend l'effet k2000 de ton prog :

Code:

// 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(B00000110);       
  allumeLED(B00000011);       
  allumeLED(B00001110);       
  allumeLED(B00011100);       
  allumeLED(B00111000);       
  allumeLED(B01110000);
  allumeLED(B11100000);

et au lieu d'avoir 3 Dels allumées à la fois, tu n'en mets qu'une :

Code:

for (int j=0; j<10; j++) { //boucle de répétition x 10

  allumeLED(B10000000); // appelle la fonction qui met les LEDs dans l'état des bits
  allumeLED(B01000000);       
  allumeLED(B00100000);       
  allumeLED(B00010000);       
  allumeLED(B00000100);       
  allumeLED(B00000010);
  allumeLED(B00000001);       
  allumeLED(B00000010);       
  allumeLED(B00000100);       
  allumeLED(B00001000);       
  allumeLED(B00010000);
  allumeLED(B00100000);
  allumeLED(B01000000);
  allumeLED(B10000000);

ensuite tu n'as plus qu'a le mettre où tu veux et comme tu veux 
j'espère t'avoir aidé  @plus et bon courage 

[Reply #7 on:]

Merci de ta réponse cela je l'avais installé avec 3 led mais meme avec un seul led l'effet demandé n'est pas concluant
car les leds s'éteingne directement l'une après l'autre sans cette effet d'atténuation
 et c'est ce que je voudrai mettre dans ce code et ceci pour tout les effets déja présent
j'espere que tu ma compris
merci a toi de ton aide pour la suite car cela est très important pour moi j'ai un projet de maquette pour ce dimanche et il me faut absolument ce code et cet effet
merci d'avance

[Reply #8 on:]

Salut,

Tout d'abord, tu as déjà ouvert un post pour le même sujet. On évite les doublons sur un forum!

Ensuite, il n'y a jamais d'urgence sur un forum. Donc s'il te faut le code pour dimanche, disons 10h du matin, il te reste 39,5h pour te pencher dessus.

Allez, je ne suis pas vache: penche toi du côté de la librairie SoftPWM, qui te permettra d'allumer tes leds à l'intensité souhaitée, sur n'importe quelle broche digitale (comme te l'a montré AlienArea51 sur ton autre post).

[Reply #9 on:]

Sujets fusionnés

Ménage fait

Alien... j'étais en train de le faire 

[Reply #10 on:]

Oupsssssssssss désoler pour avoir fait se désagrément
je ne trouvais plus mon ancien post
enfin quoi qu'il en soit je ne vais pas embrouillé votre forum
encore milles excuses pour le dérangement
je vais me débrouillé avec se que je sais sans plus
enfin merci a tous et encore désolé

[Reply #11 on:]

@AlienArea51: je n'ai pas à te pardonner, tu n'as rien fait de mal. Au contraire, tu es le seul à avoir proposé la lib SoftPWM, donc grand bravo

@Flippers: ne te méprends pas, on aide les gens quand on sait, et quand on a le temps. Il y a juste quelques règles à respecter, telle que n'ouvrir qu'un topic par problème (et encore, il arrive que nous restions sur le même pour d'autres aspects d'un problème ou d'un projet, simplement parce qu'il y a l'historique des réponses et donc pour ne pas avoir à chercher sur 50 pages les anciens topics).

Donne nous les résultats de tes essais avec le code d'AlienArea51, avec tes modifications, avec tes idées... Recommencer un topic résume à recommencer de zéro: on te proposera le même code, tu auras les mêmes réponses qu'avant...

EDIT: tu peux rester et continuer de poster! On te répondra dans la mesure de nos connaissances

[Reply #12 on:]

J'ai l'air un peu méchant, mais c'est pas le cas.... reste et continue ton sujet. 

[Reply #13 on:]

Merci de ta comprehenssion pour le sujet et le code de @AlienArea51 celui ci ne fonctionne pas il me met deux erreur pourquoi ??? je ne sais pas j'ai du mal a comprendre les codes arduino mais bon j'essai par la mesure du possible quoi qu'il en sois merci a toi je vous tient au courant des que j'ai trouvé