Bonjour a tous,

Je cherche a modifier un code qui joue une animation "arc en ciel",

celle ci fonctionne sur un automate qui joue plusieurs scène à la suite mais , je me suis lancé dans le pilotage avec une commande IR,

le problème c'est bien sur qu'il ne coupe pas les boucles en cas de nouveau code,

j'ai tenté de créer une interruption sur le pin de réception du signal, mais ça ne fonctionne pas,

j'ai aussi tenté de modifier le code pour supprimer les 2 boucles et passer sur des conditions, mais là, le programme ne joue plus rien,

je pense avoir une problème avec  " uint16_t i, j;" , mais cela dépasse mes compétences,

j'ai tenté de poser un delay entre chaque tour de boucle, mais cela est inutile, il ne reçois pas le code pendant un delay.

J'ai aussi tenté d'utiliser la fonction millis mais , mes connaissance ne sont pas asser bonne et cela ne fonction pas.

Avant de me gratter la tête jusqu'en être chauve, je vous demanderais donc conseil pour pouvoir sortir de cette animation une fois lancé.

Si un spécialiste des bandes Led lit cela, j'ai besoin de conseil ! SVP

Ps : mon programme fonctionne avec des éclairages statique et avec des chenillards programmer en IF.

Mon code :

void rainbow_mur(uint8_t wait) {
  uint16_t i, j;
  for(j=256; j>0; j--) {
    for(i=0; i<164; i++) {
      pixels2.setPixelColor(i, Wheel((i+j) & 255));
      pixels.setPixelColor(i, Wheel((i+j) & 255));
    }
    
show();
    }
    
delay(2500);
}


/////////////////////////////////////////////////////////////////
//////         routine animation rainbow                  ///////
/////////////////////////////////////////////////////////////////

// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return pixels.Color(255 - WheelPos * 3, 0, WheelPos * 3);
    return pixels2.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return pixels.Color(0, WheelPos * 3, 255 - WheelPos * 3);
    return pixels2.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return pixels.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  return pixels2.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}

Merci d'avance !

Une petite idée du rendu

-
Edité par bucheron créatif 15 janvier 2017 à 22:46:43

Il y  a déjà un petit souci là

uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return pixels.Color(255 - WheelPos * 3, 0, WheelPos * 3);
    return pixels2.Color(255 - WheelPos * 3, 0, WheelPos * 3);  // popopo!
  }

Quand WheelPos < 85,  la fonction retourne la valeur pixels.Color(255 - WheelPos * 3, 0, WheelPos * 3);

et ça s'en arrête là. On a fait return, on est ressorti de la fonction. Le second return n'est pas exécuté.

 Enfin, ça n'a pas l'air trop grave. Ca a l'air de retourner la même couleur de toutes façons.

Encore que les paramètres de Color ne paraissent pas être entre 0 et 255.

---

Ce qui manque, c'est la logique de ton appli. Ce qu'il y a dans loop().

-
Edité par michelbillaud 15 janvier 2017 à 22:56:23

Ok, merci du conseil, enfaite j'ai juste fait une erreur en "doublant " le show sur mes 2bandes, il aurais fallut faire tourner deux shows , et là j'ai juste fait fonctionner les 2 bandes sur le même show.Je reprendrais l'animation pour que l'arc en ciel défile bien sur les 2bandes.je voudrais en plus laisser les Led de 0 a 42 et de 122 a 164 de la bande 2 allumées en blanc ( dessus et dessous de mon meuble murale ).

Mais cela n'est pas mon gros problème, c'est surtout que une fois cette animation lancé, je ne peut plus l’interrompre ! donc l'arc en ciel c'est sympa mais au bout de 20 minute , y'en a marre ! et la il faut débrancher le boitier pour pouvoir changer l’éclairage !

voici mon code complet : il pilote 2 bandes de led avec une commande IR, Les case de mes meubles sont rangé en tableau que j’appelle directement, J'ai créé quelques chenillards test , certaines fonctions sont incomplètes car il me sert de test alors j'en ajoute et enlève par moment.des "Int" sont inutile aussi mais me servent pour d’autres fonction.

// PROGRAMME PERMETTANT D'ALLUMER LA LED CORESPONDANTE A LA TOUCHE DE LA TELECOMMANDE EN BLEU

#include <IRremote.h>   // bibliotheque de gestion de l'infra rouge
#include <Adafruit_NeoPixel.h>    // bibliotheque de gestion des LED

// déclaration pour la réception IR.
IRrecv reception_ir(11); // créer une instance pour réceptionner l'IR sur la broche 11
decode_results decode_ir; // stockage données reçues
// fin déclaration

// déclaration pour la bande LED
Adafruit_NeoPixel pixels2 = Adafruit_NeoPixel(164, 7);  // créer une instance pour piloter 10 LED par la borne 4
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(132, 6);  // créer une instance pour piloter 10 LED par la borne 4
// findéclaration

// déclaration variables divers
unsigned long temps; // variable de stockage de temps
int donneeIR;   //stock le code de l'IR filtré
int touche;     // numéro de la touche appuyée sur la télécommande (-1=erreur et 9999=touche OK)
int num_anim=99;       // nouveau numéro de l'annimation sélectionné
int num_anim_hold=99;  // numéro de l'annimation en cours

int ind_anim_0=132;
int ind_anim_0j=0;
int ind_anim_01=999;
int ind_anim_1=0;
int ind_anim_2=0;
int ind_anim_3=9;
int ind_anim_4=9;
int ind_anim_5=9;

// fin déclaration

void setup()
{
  Serial.begin(9600); 
  reception_ir.enableIRIn(); // démarre la réception
  pixels.begin();   // démarre la gestion de la bande LED
  pixels2.begin();   // démarre la gestion de la bande LED
  pixels.show(); // This sends the updated pixel color to the hardware.
  pixels2.show(); // This sends the updated pixel color to the hardware.
}

void loop()
{
  if (reception_ir.decode(&decode_ir))  // si code IR réceptionné on éxécute le programme
  { 
    if (decode_ir.value != donneeIR)  // filtre les doublons
    {
      donneeIR=decode_ir.value;   // récupère le nouveau code IR
      touche=Decod(donneeIR);   // décode le code IR
      if(touche==-1)  // traitement du code d'erreur fait s'allumer les LED en rouge
      {
        Serial.print("erreur de lecture IR ");
        Serial.println(decode_ir.value, DEC);
      }
      else    // sinon allumage de la LED corespondante
      {
        num_anim=touche;
      }
    }
    reception_ir.resume(); // reçoit le prochain code
  }

// Traitement des animations
  if(num_anim==num_anim_hold) // si pas de changement d'animation
  {
    if(millis()-temps>200)  // ne s'éxécute que toutes les 0.2 secondes
    {
      temps=millis();
 
 
      if(num_anim_hold==0)  // touche off
      {
      Tt(pixels.Color(0, 0, 0), 50);
      }
      if(num_anim_hold==1)  // touche disp
      {
      Tt(pixels.Color(25, 25, 25), 50);
      }
      if(num_anim_hold==2)  // touche menu
      {
      Tt(pixels.Color(120, 120, 120), 50);
      }
      if(num_anim_hold==3)  // touche top
      {
      Tt(pixels.Color(250, 250, 250), 50);
      }
      if(num_anim_hold==4)  // touche setup
      {
      T11(pixels.Color(250, 0, 0), 50);
      T12(pixels.Color(250, 0, 0), 50);
      T21(pixels.Color(250, 0, 0), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(250, 0, 0), 50);
      T269(pixels.Color(250, 0, 0), 50);
      }
      if(num_anim_hold==5)  // touche list
      {
      T11(pixels.Color(0, 250, 0), 50);
      T12(pixels.Color(0, 250, 0), 50);
      T21(pixels.Color(0, 250, 0), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(0, 250, 0), 50);
      T269(pixels.Color(0, 250, 0), 50);
      }
      if(num_anim_hold==6)  //touche ret
      {
      T11(pixels.Color(0, 0, 250), 50);
      T12(pixels.Color(0, 0, 250), 50);
      T21(pixels.Color(0, 0, 250), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(0, 0, 250), 50);
      T269(pixels.Color(0, 0, 250), 50);
      }
      if(num_anim_hold==7)  //touche play
      {
      T11(pixels.Color(0, 100, 250), 50);
      T12(pixels.Color(0, 100, 250), 50);
      T21(pixels.Color(0, 100, 250), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(0, 100, 250), 50);
      T269(pixels.Color(0, 100, 100), 50);
      }
      if(num_anim_hold==8)  //touche  retour
      {
      T11(pixels.Color(0, 0, 0), 50);
      T12(pixels.Color(0, 0, 0), 50);
      T21(pixels.Color(0, 0, 20), 50);
      T210(pixels.Color(150, 150, 150), 50);
      T22(pixels.Color(0, 40, 80), 50);
      T23(pixels.Color(40, 0, 80), 50);
      T24(pixels.Color(0, 40, 80), 50);
      T25(pixels.Color(80, 0, 40), 50);
      T26(pixels.Color(80, 40, 0), 50);
      T27(pixels.Color(0, 80, 40), 50);
      T28(pixels.Color(40, 80, 0), 50);
      T29(pixels.Color(20, 80, 20), 50);
     }
      if(num_anim_hold==9)  //touche avance
      {
      T11(pixels.Color(0, 0, 0), 50);
      T12(pixels.Color(0, 0, 0), 50);
      T21(pixels.Color(0, 0, 10), 50);
      T210(pixels.Color(30, 30, 30), 50);
      T225(pixels.Color(10, 0, 50), 50);
      T269(pixels.Color(50, 0, 10), 50);
      }
      show();

      if(num_anim_hold==10)  // ctouche stop
      {
      T11(pixels.Color(100, 0, 250), 50);
      T12(pixels.Color(100, 0, 250), 50);
      T21(pixels.Color(100, 0, 250), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(100, 0, 250), 50);
      T269(pixels.Color(100, 0, 250), 50);
      }
      if(num_anim_hold==11)  // touche fold up
      {
      T11(pixels.Color(0, 100, 250), 50);
      T12(pixels.Color(0, 100, 250), 50);
      T21(pixels.Color(0, 100, 250), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(0, 100, 250), 50);
      T269(pixels.Color(0, 100, 250), 50);
      }
      if(num_anim_hold==12)  // ctouche fold down
      {
      T11(pixels.Color(100, 250, 0), 50);
      T12(pixels.Color(100, 250, 0), 50);
      T21(pixels.Color(100, 250, 0), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(100, 250, 0), 50);
      T269(pixels.Color(100, 250, 0), 50);
      }
      if(num_anim_hold==13)  // touche rep
      {
      T11(pixels.Color(250, 100, 0), 50);
      T12(pixels.Color(250, 100, 0), 50);
      T21(pixels.Color(250, 100, 0), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(250, 100, 0), 50);
      T269(pixels.Color(250, 100, 0), 50);
      }
      if(num_anim_hold==14)  // touche mix
      {
      T11(pixels.Color(250, 0, 100), 50);
      T12(pixels.Color(250, 0, 100), 50);
      T21(pixels.Color(250, 0, 100), 50);
      T210(pixels.Color(50, 50, 50), 50);
      T225(pixels.Color(250, 0, 100), 50);
      T269(pixels.Color(250, 0, 100), 50);
      }
      if(num_anim_hold==15)  // touche audio
      {
      chenillard_vert(pixels.Color(0, 255, 0), 1);
      T21(pixels.Color(255, 255, 255), 50);
      T210(pixels.Color(100, 100, 100), 50);
      }
      if(num_anim_hold==16)  // touche sub
      {
      chenillard_bleu(pixels.Color(0, 0, 255), 1);
      T21(pixels.Color(255, 255, 255), 50);
      T210(pixels.Color(100, 100, 100), 50);
      }
      if(num_anim_hold==17)  // touche angle
      {
      chenillard_rouge(pixels.Color(255, 0, 0), 1);
      T21(pixels.Color(255, 255, 255), 50);
      T210(pixels.Color(100, 100, 100), 50);
      }
      if(num_anim_hold==18)  // touche clr
      {
      T11(pixels.Color(200, 200, 200), 1);
      }
      if(num_anim_hold==19)  // touche v out
      {
      T12(pixels.Color(200, 200, 200), 1);
      }
      if(num_anim_hold==21)  // touche no1
      {
      T210(pixels.Color(50, 50, 50), 1);
      T225(pixels.Color(0, 5, 100), 1);
      T269(pixels.Color(0, 0, 100), 1);
      }
      if(num_anim_hold==22)  // touche no2
      {
      rainbow_mur(10);                                                                                            ///////////////
      }
      if(num_anim_hold==23)  // touche no0
      {
      T12(pixels.Color(0, 0, 0), 1);
      T11(pixels.Color(0, 0, 0), 1);
      }


    }
  }
  else  // si changement d'animation
  {
    num_anim_hold=num_anim;
    if (num_anim>0&&num_anim<18)
    {Init_Led();
    }
    Serial.print("num_anim : ");
    Serial.println(num_anim_hold, DEC);
    Serial.println(decode_ir.value, DEC);
  }
}

// FONCTION
void Init_Led()   // met les LED à 0
{
  for(int ind=0;ind<170;ind++)
  {
    pixels.setPixelColor(ind, 0, 0, 0);
    pixels2.setPixelColor(ind, 0, 0, 0);
  }
  show();
}

void Erreur_Led()   // alume les LED en rouge pour signifier une erreur de réception IR
{
  for(int ind=0;ind<10;ind++)
  {
    pixels.setPixelColor(ind, 255, 0, 0);
    pixels2.setPixelColor(ind, 255, 0, 0);
  }
  pixels.show();
}

int Decod(int appui_touche)   // décode l'appuie sur une touche
{
  int retour_decod=-1; //déclaration d'une variable de retour local si le retour est à -1->erreur

  switch(appui_touche)    // décodage du code IR
  {
    // l'appuie sur la touche renvoi une valeur différente une fois sur deux, je teste donc les deux possibilité pour chaque touche.
    case 2944 :
      retour_decod=0;
    break;
    case 1634756759 :
      retour_decod=0;
    break;
    case 896 :
      retour_decod=0;
    break;
    case 3788375801 :
      retour_decod=0;
    break;
    case 1634789399 :
      retour_decod=1;
    break;
    case 904 :
      retour_decod=1;
    break;
    case 2952 :
      retour_decod=1;
    break;
    case 3788379881 :
      retour_decod=1;
    break;
    case 1634736359 :
      retour_decod=2;
    break;
    case 2946 :
      retour_decod=2;
    break;
    case 898 :
      retour_decod=2;
    break;
    case 3788416601 :
      retour_decod=2;
    break;
    case 1634768999 :
      retour_decod=3;
    break;
    case 899 :
      retour_decod=3;
    break;
    case 2947 :
      retour_decod=3;
    break;
    case 3788383961 :
      retour_decod=3;
    break;
    case 2948 :
      retour_decod=4;
    break;
    case 900 :
      retour_decod=4;
    break;
    case 3788377841 : 
      retour_decod=4;
    break;
    case 901 :
      retour_decod=5;
    break;
    case 2949 :
      retour_decod=5;
    break;
    case 3788429861 : 
      retour_decod=5;
    break;
    case 2950 :
      retour_decod=6;
    break;
    case 902 :
      retour_decod=6;
    break;
    case 3788408441 : 
      retour_decod=6;
    break;
    case 903 :
      retour_decod=7;
    break;
    case 2951 :
      retour_decod=7;
    break;
    case 3788386001 : 
      retour_decod=7;
    break;
    case 2945 :
      retour_decod=8;
    break;
    case 897 :
      retour_decod=8;
    break;
    case 3788379371 :
      retour_decod=8;
    break;
    case 905 :
      retour_decod=9;
    break;
    case 2953 :
      retour_decod=9;
    break;
    case 3788412011 :
      retour_decod=9;
    break;
    case 3788396201 :
      retour_decod=10;
    break;
    case 3788413541 :
      retour_decod=11;
    break;
    case 3788397221 :
      retour_decod=12;
    break;
    case 3788404361 :
      retour_decod=13;
    break;
    case 3788420681 :
      retour_decod=14;
    break;
    case 3788397731 :
      retour_decod=15;
    break;
    case 3788410481 :
      retour_decod=16;
    break;
    case 3788426801 :
      retour_decod=17;
    break;
    case 3788414051 :
      retour_decod=18;
    break;
    case 3788432921 :
      retour_decod=19;
    break;
    case 3788436491 :
      retour_decod=21;
    break;
    case 3788377331 :
      retour_decod=22;
    break;
    case 3788403851 :
      retour_decod=23;
    break;




















    case 913 :    // touche OK
      retour_decod=9999;
    break;
    case 2961 :    // touche OK
      retour_decod=9999;
    break;
  }

//  retour_decod=appui_touche;  //ligne permettant de renvoyer le code brute

  return retour_decod;
}


/////////////////////////////////////////////////////////////////
//////           liste des tableaux de LED            ///////////
/////////////////////////////////////////////////////////////////

void T11(uint32_t c, uint8_t wait) {
  for(uint16_t i=132; i>62; i--) {
    pixels.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T11(pixels.Color(0, 0, 20), 50);

void T12(uint32_t c, uint8_t wait) {
  for(uint16_t i=62; i>0; i--) {
    pixels.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T12(pixels.Color(0, 0, 20), 50);



void T21(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<42; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T21(pixels2.Color(0, 0, 20), 50);

void T22(uint32_t c, uint8_t wait) {
  for(uint16_t i=42; i<52; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T22(pixels2.Color(0, 0, 20), 50);

void T23(uint32_t c, uint8_t wait) {
  for(uint16_t i=52; i<62; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T23(pixels2.Color(0, 0, 20), 50);

void T24(uint32_t c, uint8_t wait) {
  for(uint16_t i=62; i<72; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T24(pixels2.Color(0, 0, 20), 50);

void T25(uint32_t c, uint8_t wait) {
  for(uint16_t i=72; i<82; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T25(pixels2.Color(0, 0, 20), 50);

void T26(uint32_t c, uint8_t wait) {
  for(uint16_t i=82; i<92; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T26(pixels2.Color(0, 0, 20), 50);

void T27(uint32_t c, uint8_t wait) {
  for(uint16_t i=92; i<102; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T27(pixels2.Color(0, 0, 20), 50);

void T28(uint32_t c, uint8_t wait) {
  for(uint16_t i=102; i<112; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T28(pixels2.Color(0, 0, 20), 50);

void T29(uint32_t c, uint8_t wait) {
  for(uint16_t i=112; i<122; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T29(pixels2.Color(0, 0, 20), 50);

void T210(uint32_t c, uint8_t wait) {
  for(uint16_t i=122; i<164; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T210(pixels2.Color(0, 0, 20), 50);

void T225(uint32_t c, uint8_t wait) {
  for(uint16_t i=42; i<82; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T225(pixels2.Color(0, 0, 20), 50);

void T269(uint32_t c, uint8_t wait) {
  for(uint16_t i=82; i<122; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   T269(pixels2.Color(0, 0, 20), 50);




void Tt(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<164; i++) {
    pixels.setPixelColor(i, c);
  }
  for(uint16_t i=0; i<164; i++) {
    pixels2.setPixelColor(i, c);
  }
}
///////////////////////////////// commande :   Tt(pixels2.Color(0, 0, 20), 50);


void show()
{
  pixels.show(); // This sends the updated pixel color to the hardware.
  pixels2.show(); // This sends the updated pixel color to the hardware.
}

///////////////////////////////////////////////////////////////////////////////
////////   liste des Shows      //////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////


void rainbow_mur(uint8_t wait) {
  uint16_t i, j;
  for(j=256; j>0; j--) {
    for(i=0; i<164; i++) {
      pixels2.setPixelColor(i, Wheel((i+j) & 255));
      pixels.setPixelColor(i, Wheel((i+j) & 255));
    }
    
show();
    }
    
delay(2500);
}


/////////////////////////////////////////////////////////////////
//////         routine animation rainbow                  ///////
/////////////////////////////////////////////////////////////////

// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return pixels.Color(255 - WheelPos * 3, 0, WheelPos * 3);
    return pixels2.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return pixels.Color(0, WheelPos * 3, 255 - WheelPos * 3);
    return pixels2.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return pixels.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  return pixels2.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}





void chenillard_rouge(uint32_t c, uint8_t wait)
  {
  
       Tt(pixels.Color(50, 0, 150), 1); // permet de changer la couleur du fond
 
        if(ind_anim_0>-3 && ind_anim_0<132)
        {
          pixels.setPixelColor(ind_anim_0+3, 50, 0, 0);
          pixels.setPixelColor(ind_anim_0+2, 85, 0, 0);
          pixels.setPixelColor(ind_anim_0+1, c);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
        if(ind_anim_0==132)
        {
          pixels2.setPixelColor(161, 50, 0, 0);
          pixels2.setPixelColor(162, 85, 0, 0);
          pixels2.setPixelColor(163, c);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
         if(ind_anim_0==131)
        {
          pixels2.setPixelColor(162, 50, 0, 0);
          pixels2.setPixelColor(163, 85, 0, 0);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
        if(ind_anim_0==130)
        {
          pixels2.setPixelColor(163, 50, 0, 0);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
        if(ind_anim_0==-1)
        {
          pixels2.setPixelColor(1, c);
        }
        if(ind_anim_0==-2)
        {
          pixels2.setPixelColor(2, c);
          pixels2.setPixelColor(1, c);
          ind_anim_01=3;
          ind_anim_0=144;
        }
        if(ind_anim_0==-3)
        {
          pixels2.setPixelColor(3, 85, 0, 0);
          pixels2.setPixelColor(2, c);
          pixels2.setPixelColor(1, c);
          ind_anim_01=3;
          ind_anim_0=144;
        }



        if(ind_anim_01>0 && ind_anim_01<163)
        {
          pixels2.setPixelColor(ind_anim_01-3, 50, 0, 0);
          pixels2.setPixelColor(ind_anim_01-2, 85, 0, 0);
          pixels2.setPixelColor(ind_anim_01-1, 255, 0, 0);
          pixels2.setPixelColor(ind_anim_01, c);
          ind_anim_01++;
        }
        if(ind_anim_01==163)
        {
          ind_anim_0=132;
          ind_anim_01=166;
        }


  }  
void chenillard_bleu(uint32_t c, uint8_t wait)
  {
  
       Tt(pixels.Color(30, 10, 0), 50); // permet de changer la couleur du fond
 
        if(ind_anim_0>-3 && ind_anim_0<132)
        {
          pixels.setPixelColor(ind_anim_0+3, 0, 0, 50);
          pixels.setPixelColor(ind_anim_0+2, 0, 0, 85);
          pixels.setPixelColor(ind_anim_0+1, 0, 0, 200);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
        if(ind_anim_0==132)
        {
          pixels2.setPixelColor(161, 0, 0, 50);
          pixels2.setPixelColor(162, 0, 0, 85);
          pixels2.setPixelColor(163, 0, 0, 200);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
         if(ind_anim_0==131)
        {
          pixels2.setPixelColor(162, 0, 0, 50);
          pixels2.setPixelColor(163, 0, 0, 85);
          pixels.setPixelColor(ind_anim_0, 0, 0, 200);
          ind_anim_0--;
        }
        if(ind_anim_0==130)
        {
          pixels2.setPixelColor(163, 0, 0, 50);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
        if(ind_anim_0==-1)
        {
          pixels2.setPixelColor(1, c);
        }
        if(ind_anim_0==-2)
        {
          pixels2.setPixelColor(2, 0, 0, 200);
          pixels2.setPixelColor(1, c);
          ind_anim_01=3;
          ind_anim_0=144;
        }
        if(ind_anim_0==-3)
        {
          pixels2.setPixelColor(3, 0, 0, 85);
          pixels2.setPixelColor(2, 0, 0, 200);
          pixels2.setPixelColor(1, c);
          ind_anim_01=3;
          ind_anim_0=144;
        }



        if(ind_anim_01>0 && ind_anim_01<163)
        {
          pixels2.setPixelColor(ind_anim_01-3, 0, 0, 50);
          pixels2.setPixelColor(ind_anim_01-2, 0, 0, 85);
          pixels2.setPixelColor(ind_anim_01-1, 0, 0, 200);
          pixels2.setPixelColor(ind_anim_01, c);
          ind_anim_01++;
        }
        if(ind_anim_01==163)
        {
          ind_anim_0=132;
          ind_anim_01=166;
        }


  }  
void chenillard_rouge_Jaf(uint32_t c, uint8_t wait)
  {
  
       Tt(pixels.Color(10, 0, 20), 50); // permet de changer la couleur du fond
 
        if(ind_anim_0j>0 && ind_anim_0j<10)
        {
          pixels.setPixelColor(ind_anim_0j-1, c);
          pixels.setPixelColor(ind_anim_0j, c);
          ind_anim_0j++;
        }
        if(ind_anim_0j==0)
        {
          pixels.setPixelColor(9, c);
          pixels.setPixelColor(ind_anim_0j, c);
          ind_anim_0j++;
        }
        if(ind_anim_0j==10)
        {
          ind_anim_0j=0;
        }
  }

void chenillard_vert(uint32_t c, uint8_t wait)
  {
       Tt(pixels.Color(100, 0, 100), 5); // permet de changer la couleur du fond
 
        if(ind_anim_0>-3 && ind_anim_0<132)
        {
          pixels.setPixelColor(ind_anim_0+3, 0, 50, 0);
          pixels.setPixelColor(ind_anim_0+2, 0, 85, 0);
          pixels.setPixelColor(ind_anim_0+1, 0, 200, 0);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
        if(ind_anim_0==132)
        {
          pixels2.setPixelColor(161, 0, 50, 0);
          pixels2.setPixelColor(162, 0, 85, 0);
          pixels2.setPixelColor(163, 0, 200, 0);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
         if(ind_anim_0==131)
        {
          pixels2.setPixelColor(162, 0, 50, 0);
          pixels2.setPixelColor(163, 0, 85, 0);
          pixels.setPixelColor(ind_anim_0, 0, 200, 0);
          ind_anim_0--;
        }
        if(ind_anim_0==130)
        {
          pixels2.setPixelColor(163, 0, 50, 0);
          pixels.setPixelColor(ind_anim_0, c);
          ind_anim_0--;
        }
        if(ind_anim_0==-1)
        {
          pixels2.setPixelColor(1, c);
        }
        if(ind_anim_0==-2)
        {
          pixels2.setPixelColor(2, 0, 200, 0);
          pixels2.setPixelColor(1, c);
          ind_anim_01=3;
          ind_anim_0=144;
        }
        if(ind_anim_0==-3)
        {
          pixels2.setPixelColor(3, 0, 50, 0);
          pixels2.setPixelColor(2, 0, 200, 0);
          pixels2.setPixelColor(1, c);
          ind_anim_01=3;
          ind_anim_0=144;
        }



        if(ind_anim_01>0 && ind_anim_01<163)
        {
          pixels2.setPixelColor(ind_anim_01-3, 0, 50, 0);
          pixels2.setPixelColor(ind_anim_01-2, 0, 85, 0);
          pixels2.setPixelColor(ind_anim_01-1, 0, 200, 0);
          pixels2.setPixelColor(ind_anim_01, c);
          ind_anim_01++;
        }
        if(ind_anim_01==163)
        {
          ind_anim_0=132;
          ind_anim_01=166;
        }


  }
  
  

  
  
  
  
  
  

Voila, la priorité est vraiment d’interrompre cette animation, le reste sera repris plus tard, et désoler pour les initié ça peut vous piquer un peu les yeux ! Mais j’apprends de moi même !

Je vais aussi revoir entièrement le fonctionnement du système, une case de mon meuble par touche de la commande, c'est a dire que chaque appuis fera changer la couleur de la case, et un bouton pour changer toutes les cases, et certains pour jouer des animations.

Plus tard , après pas mal de connaissance en plus, je tenterai de gérer plusieurs boitier esclave par un maitre pour jouer des animations dans toues la pièces, et aussi ajouter des capteurs de présence , mais d'ici la je serais surement vieux , enfin plus que maintenant !

-
Edité par bucheron créatif 15 janvier 2017 à 23:08:28