Projet Initial Map

L’écran tactile va nous permettre de créer une interface grâce a laquelle l’utilisateur pourra contrôler le mapping. Afin de mettre en place cet outil, nous allons procéder de la manière suivante :

Initialisation de l’écran et des données utiles

Création de l’interface.

Mise en place des fonctions de contrôle.

Programmation du Loop (fonction principale du programme).

Pour que l’écran fonctionne, nous allons d’abord le connecter à l’Arduino. Une fois l’écran connecté et l’Arduino mise sous tension, l’écran s’allume en blanc.

Pour commencer nous allons importer les bibliothèques qui nous permettrons d’utiliser l’écran.

// Innovation - Project : Initial Map

#include <Adafruit_GFX.h>     // Core graphics library
#include <Adafruit_TFTLCD.h>  // Hardware-specific library
#include <TouchScreen.h>     

Les  deux  bibliothèques  Adafruit  sont  des  librairies  liées  à  l’écran  qui  nous  permettrons  d’utiliser certaines fonctions ainsi que les entrées/sorties qui lui sont propres. La librairie TouchScreen elle nous permettra d’utiliser le coté tactile de l’écran.

Ensuite nous devons définir les pins qui connecte l’écran à l’Arduino ainsi que les dimensions de l’écran (les valeurs  x/y  des pixel aux extrémités de l’écran que nous déterminerons grâce a une fonction que  nous verrons).

/*--------------------DEFINE PINS--------------------*/

#define LCD_CS A3
#define LCD_CD A2
#define LCD_WR A1
#define LCD_RD A0
#define LCD_RESET A4

#define YP A3  // must be an analog pin
#define XM A2  // must be an analog pin
#define YM 9   // can be a digital pin
#define XP 8   // can be a digital pin

/*--------------------DEFINE SCREEN SIZE--------------------*/

#define TS_MINX 140
#define TS_MAXX 900

#define TS_MINY 100
#define TS_MAXY 950

Maintenant nous allons définir les noms et les valeurs des données que nous utiliserons plus tard dans le programme. Tout  d’abord  les  couleurs, car il sera en effet plus  simple de  les appeler  par leur nom plutôt que par leur code. Ensuite  suivent  les données utiles  comme  l’identifiant  de  l’écran  qui  nous permettra de l’initialiser juste après ou encore la valeur minimal et maximale de la pression (qui  nous  permettra de limiter les appels aux fonctions seulement quand l’écran sera touché.

/*--------------------DEFINE COLORS NAMES--------------------*/

#define WHITE   0xFFFF 
#define BLACK   0x0000 //used
#define BLUE    0x001F //used
#define RED     0xF800 //used
#define GREEN   0x07E0 //used
#define CYAN    0x07FF //used
#define YELLOW  0xFFE0 //used
#define GREY    0xBDF7 //used
#define GREY2   0x7BEF //used
#define ORANGE  0xFD20 //used
#define PURPLE  0x780F //used
#define OLIVE   0x7BE0 //used
#define SEA     0x07F0 //used

/*--------------------DEFINE PERSONAL DATA--------------------*/

#define identifier 0x9341 //for test-screen
#define MINPRESSURE 10    //Define a min/max 
#define MAXPRESSURE 1000  //pressure

Enfin nous définirons par quels pins les information tactile devront circuler et nous inclurons la bibliothèque du shield tft (l’écran).

/*--------------------TOUCHSCREEN/SHIELD INITIALISATION--------------------*/

TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;

Pour qu’un programme Arduino fonctionne, il lui faut deux fonctions que sont SETUP et LOOP.

Ici nous parlerons de la fonction Setup qui ne s’exécute qu’une seule fois au début du programme. C’est grâce à elle que nous allons créer le squelette de notre interface.

Voici ce que nous allons réaliser :

(photo écran)

Pour ce faire nous allons out d’abord initialiser la connexion avec le  port Série  qui nous permettra  de récupérer des informations plus tard. ( Serial.begin(9600) ).

Ensuite on demande à l’écran de s’allumer et de se mettre en mode paysage ( tft.setRotation(1) ).

/*--------------------SETUP--------------------*/

void setup()
{
  Serial.begin(9600);   //Serial Port Initialisation
  Serial.println("Initial Map - Arduino mapping");
  tft.reset();
  tft.begin(identifier);
  tft.setRotation(1);

Nous allons enfin pouvoir commencer à faire apparaitre des formes sur notre écran. En ce servant des différentes fonctions nous allons pouvoir créer :

• Des rectangles : tft.drawRect( x, y , dx, dy, color)  ou x et y sont les emplacements du coin en haut à gauche de l’écran et  dx  et  dy  les déplacements qui donneront les positions du coin en bas à  droite.
• Des cercles : tft.drawCircle( x, y, r, color)  ou  x  et  y  sont les positions du centre du cercle et  r  le rayon.
• Des lignes : tft.drawLine( x, y, x’, y’, color) ou x et y sont les position d’une extrémité du segment et x’ et y’ les positions de l’autre extrémité du segment.

A noter que pour que les figures soient remplies par la couleur on remplacera "draw" par "fill".

//Draw
  tft.fillScreen(BLACK);

//Volume
  tft.fillRect(20, 20, 30, 200, GREEN);
  tft.drawRect(20, 20, 30, 200, GREY2);

//Button Play/Pause
  tft.fillCircle(180, 190, 20, GREEN);
  tft.drawCircle(180, 190, 20, GREY2);
  tft.setTextColor(BLUE);tft.setCursor(166,187);tft.print("BEGIN");

//Button Back
  tft.fillCircle(110, 190, 20, GREEN);
  tft.drawCircle(110, 190, 20, GREY2);
  for(int i=0;i<10;i++){
    tft.drawLine(110+i,190+i,110+i,190-i,RED);
    tft.drawLine(100+i,190+i,100+i,190-i,RED);
  }

//Button After
  tft.fillCircle(250, 190, 20, GREEN);
  tft.drawCircle(250, 190, 20, GREY2);
  for(int i=0;i<10;i++){
    tft.drawLine(243+i,180+i,243+i,200-i,RED);
    tft.drawLine(253+i,180+i,253+i,200-i,RED);
  }

Vous remarquerez qu’il n’existe  pas de fonction pour tracer un triangle, il a donc fallu en créer une.      Pour ce faire,  il suffit de dessiner successivement des lignes de plus en plus petites ou de plus en plus  grandes selon le sens que l’on veut donner à notre triangle.

Enfin,  On  peut  également  écrire  sur  l’écran  grâce  a  la  fonction  tft.print( "Message" ). Il  ne  faudra cependant  pas  oublier  d’indiquer  la  position  du  curseur sur l’écran grâce à  tft.setCursor( x, y)  et  la  couleur du texte tft.setTextColor( "color"’).

//Text Bar
  tft.fillRect(80, 130, 200, 30, GREY);
  tft.drawRect(80, 130, 200, 30, GREY2);

//Animation Selection
  tft.fillRect(80,20,50,40,GREY);
  tft.fillRect(130,20,50,40,GREY);
  tft.fillRect(180,20,50,40,GREY);
  tft.fillRect(230,20,50,40,GREY);

  tft.drawRect(80, 20, 200, 80, CYAN);
  tft.drawLine(80, 60, 279, 60, CYAN);
  tft.drawLine(130, 20, 130, 60, CYAN);
  tft.drawLine(180, 20, 180, 60, CYAN);
  tft.drawLine(230, 20, 230, 60, CYAN);

  tft.setTextColor(RED);
  tft.setCursor(91,37);tft.print("VITRE"); 
  tft.setCursor(141,37);tft.print("PHARE");
  tft.setCursor(193,37);tft.print("ROUE");
  tft.setCursor(245,37);tft.print("FEU");

//Color Selection
  tft.fillRect(81,61,24,38,RED);
  tft.fillRect(105,61,25,38,ORANGE);
  tft.fillRect(130,61,25,38,YELLOW);
  tft.fillRect(155,61,25,38,OLIVE);
  tft.fillRect(180,61,25,38,GREEN);
  tft.fillRect(205,61,25,38,SEA);
  tft.fillRect(230,61,25,38,BLUE);
  tft.fillRect(255,61,24,38,PURPLE);
}

Nous voilà avec le squelette de notre interface dessiner.

Afin de pouvoir utiliser notre interface, il va nous falloir créer des fonctions qui renverrons des informations utiles via le port Série et qui modifierons l’aspect visuel de l’interface.

Rien de bien compliquer : il suffit de redessiner par-dessus notre squelette fait au préalable et modifier la valeur des variables en fonction de ce que nous voulons obtenir.

/*--------------------Functions--------------------*/

int play =12;
void Button_play_pause()
{
  if(play==12)
  {play=13;
   tft.fillCircle(180,190,20,GREEN);
   for (int i=0;i<10;i++){tft.drawLine(177+i,180+i,177+i,200-i,RED);}
   delay(500);
  }
  else if(play==13)
  {play=12;
   tft.fillCircle(180,190,20,GREEN);
   tft.fillRect(172,180,5,20,RED);tft.fillRect(183,180,5,20,RED);
   delay(500);
  }
} //swap value 0/1 for Button_play


void Button_after()
{
  for(int i=0;i<10;i++)
  {tft.drawLine(243+i,180+i,243+i,200-i,BLUE);
   tft.drawLine(253+i,180+i,253+i,200-i,BLUE);
  }
  delay(300);
  for(int i=0;i<10;i++)
  {tft.drawLine(243+i,180+i,243+i,200-i,RED);
   tft.drawLine(253+i,180+i,253+i,200-i,RED);
  }
  delay(500);
}


void Button_back()
{
  for(int i=0;i<10;i++)
  {tft.drawLine(110+i,190+i,110+i,190-i,BLUE);
   tft.drawLine(100+i,190+i,100+i,190-i,BLUE);
  }
  delay(300);
  for(int i=0;i<10;i++)
  {tft.drawLine(110+i,190+i,110+i,190-i,RED);
   tft.drawLine(100+i,190+i,100+i,190-i,RED);
  }
  delay(500);
}


int vitre=15;
void Vitre()
{
  if(vitre==15)
  {vitre=16;
   tft.fillRect(81,21,49,39,GREY2);
   tft.setTextColor(BLUE);tft.setCursor(91,37);tft.print("VITRE");
  }

  else if(vitre==16)
  {vitre=15;
   tft.fillRect(81,21,49,39,GREY);
   tft.setTextColor(RED);tft.setCursor(91,37);tft.print("VITRE");
  }
  delay(500);
} //swap value 0/1 for vitre


int phare=17;
void Phare()
{
  if(phare==17)
  {phare=18;
   tft.fillRect(131,21,49,39,GREY2);
   tft.setTextColor(BLUE);tft.setCursor(141,37);tft.print("PHARE");
  }

  else if(phare==18)
  {phare=17;
   tft.fillRect(131,21,49,39,GREY);
   tft.setTextColor(RED);tft.setCursor(141,37);tft.print("PHARE");
  }
  delay(500);
} //swap value 0/1 for phare


int roue=19;
void Roue()
{
  if(roue==19)
  {roue=20;
   tft.fillRect(181,21,49,39,GREY2);
   tft.setTextColor(BLUE);tft.setCursor(193,37);tft.print("ROUE");
  }

  else if(roue==20)
  {roue=19;
   tft.fillRect(181,21,49,39,GREY);
   tft.setTextColor(RED);tft.setCursor(193,37);tft.print("ROUE");
  }
  delay(500);
} //swap value 0/1 for roue


int feu=21;
void Feu()
{
  if(feu==21)
  {feu=22;
   tft.fillRect(231,21,48,38,GREY2);
   tft.setTextColor(BLUE);tft.setCursor(245,37);tft.print("FEU");
  }

  else if(feu==22)
  {feu=21;
   tft.fillRect(231,21,48,38,GREY);
   tft.setTextColor(RED);tft.setCursor(245,37);tft.print("FEU");
  }
  delay(500);
} //swap value 0/1 for feu


int track=1;
int Track(int track_changer)
{
  track += track_changer;
  tft.fillRect(81, 131, 199, 29, GREY);
  tft.setCursor(96,140);
  tft.setTextColor(BLACK);
  if(track<1){track=3;}
  if(track>3){track=1;}  
  if(track>=1 || track<=3)
  {
   switch(track){
     case 1:
       Serial.println("Initial D - Deja vu");
       tft.print("Initial D - Deja vu");
       break;
     case 2:
       Serial.println("Initial D - Gas Gas Gas");
       tft.print("Initial D - Gas Gas Gas");
       break;
     case 3:
       Serial.println("Initial D - Speed Lover");
       tft.print("Initial D - Speed Lover");
       break;
   default :
       Serial.println("No music playing...");
       tft.print("No music playing...");
       break;
     }
  }
  track+=100;
  Serial.println(track);
  track-=100;
} //Change Track value to launch and display the right song

void ResetColor(){
  tft.fillRect(81,61,24,38,RED);
  tft.fillRect(105,61,25,38,ORANGE);
  tft.fillRect(130,61,25,38,YELLOW);
  tft.fillRect(155,61,25,38,OLIVE);
  tft.fillRect(180,61,25,38,GREEN);
  tft.fillRect(205,61,25,38,SEA);
  tft.fillRect(230,61,25,38,BLUE);
  tft.fillRect(255,61,24,38,PURPLE);
}

void SetColorBar(int x){
  tft.drawLine(x+10,61,x+10,98,BLACK);
  tft.drawLine(x+11,61,x+11,98,BLACK);
}

Nous voilà avec toutes les fonctions nécessaires au bon fonctionnement du programme.

Afin de rendre l’utilisation de l’écran plus réaliste, nous allons d’abord créer une variable ‘Start’ qui ne  laissera l’utilisateur que le choix d’appuyer sur une certaine zone de l’écran pour le déclencher (sur le bouton ‘Begin’ que nous avons précédemment créé. La boucle LOOP va alors commencer à se répéter de la manière suivante :

• On regarde la position du stylet tactile sur l’écran, puis on réinitialise les pins pour qu’elle puisse transmettre des données, puis on effectue un scale qui va permettre de remettre les valeurs au nombre de pixel de l’écran (plus simple pour l’utilisation futur). Enfin on vérifie si l’écran est touché afin de déclencher nos fonctions de contrôle sinon on ne fait rien.

/*--------------------LOOP--------------------*/
int Start=0;
void loop()
{  
  digitalWrite(13, HIGH);
  TSPoint p = ts.getPoint();
  digitalWrite(13, LOW);  

  pinMode(XM, OUTPUT); //Sharing
  pinMode(YP, OUTPUT); // pins

//p.z=200;   //used if screen broken

//Scale values x:0->240 / y:0->320
  p.x = map(p.x, TS_MINX, TS_MAXX, 0,tft.height());
  p.y = (map(p.y, TS_MINY, TS_MAXY, 0, tft.width()));


  if (p.z > MINPRESSURE && p.z < MAXPRESSURE) {
    if(p.x>180 && p.y>150 && p.x<220 && p.y<190){Start=1;}
    if(Start==1){ 

/* 
Serial.print("X = "); Serial.println(p.x);
Serial.print("Y = "); Serial.println(p.y);
delay(500);
*/

/*        //IF SCREEN IS BROKEN 
Serial.println("p.x : ");  
while (Serial.available()==0)  
{}  
int  x=Serial.parseInt();
p.x = x;

Serial.println("p.y : ");  
while(Serial.available()==0)  
{}  
int  y=Serial.parseInt();
p.y = y;
//IF SCREEN IS BROKEN
*/

Remarque : Le code en commentaire a été établis  pour  pouvoir  rentrer  les  coordonnées  à  la  main au cas où l’écran soit brisé.

• La gestion du volume :

//Volume
  if(p.x>20 && p.y>10 && p.x<230 && p.y<40){
    tft.fillRect(20, 20, 30, 200, GREEN);
    if(p.x<20){}
    else if(p.x<40){tft.fillRect(20,20,30,200,RED);Serial.println(10);}
    else if (p.x<60){tft.fillRect(20,40,30,180,RED);Serial.println(9);}
    else if(p.x<80){tft.fillRect(20,60,30,160,RED);Serial.println(8);}
    else if (p.x<100){tft.fillRect(20,80,30,140,RED);Serial.println(7);}
    else if(p.x<120){tft.fillRect(20,100,30,120,RED);Serial.println(6);}
    else if (p.x<140){tft.fillRect(20,120,30,100,RED);Serial.println(5);}
    else if(p.x<160){tft.fillRect(20,140,30,80,RED);Serial.println(4);}
    else if (p.x<180){tft.fillRect(20,160,30,60,RED);Serial.println(3);}
    else if(p.x<200){tft.fillRect(20,180,30,40,RED);Serial.println(2);}
    else if (p.x<220){tft.fillRect(20,200,30,20,RED);Serial.println(1);}
    else if(p.x<230){Serial.println(0);}
    delay(100);
  }

• La gestion des musiques :

//Buttons Music
  int track;
  if(p.x>180 && p.y>80 && p.x<220 && p.y<120)
  {Button_back();Track(-1);delay(100);}//Back Touch

  if(p.x>180 && p.y>150 && p.x<220 && p.y<190)
  {Button_play_pause();Track(0);Serial.println(play);delay(100);}//Play/Pause Touch

  if(p.x>180 && p.y>220 && p.x<220 && p.y<250)
  {Button_after();Track(1);delay(100);}//After Touch

• La gestion des animations :

//Button Animation
  if(p.x>20 && p.y>70 && p.x<60 && p.y<120)
  {Vitre();Serial.println(vitre);delay(10);} //on_off vitre

  if(p.x>20 && p.y>120 && p.x<60 && p.y<170)
  {Phare();Serial.println(phare);delay(10);} //on_off phare

  if(p.x>20 && p.y>170 && p.x<60 && p.y<220)
  {Roue();Serial.println(roue);delay(10);} //on_off roue

  if(p.x>20 && p.y>220 && p.x<60 && p.y<270)
  {Feu();Serial.println(feu);delay(10);}  //on_off feu

• La gestion des couleurs :

//Color Selector
  if(p.x>60 && p.y>70 && p.x<100 && p.y<268){
    ResetColor();SetColorBar(p.y);
    if(p.y<=94){Serial.println(31);}
    if(p.y>94 && p.y<=120){Serial.println(32);}
    if(p.y>120 && p.y<=145){Serial.println(33);}
    if(p.y>145 && p.y<=170){Serial.println(34);}
     if(p.y>170 && p.y<=195){Serial.println(35);}
    if(p.y>195 && p.y<=220){Serial.println(36);}
    if(p.y>220 && p.y<=245){Serial.println(37);}
    if(p.y>245 && p.y<=269){Serial.println(38);} 
    delay(200);
  }

On  termine  le  programme  en fermant les dernières accolades des fonctions du début.

 }
 }
  delay(10);
}

Voila  le programme  Arduino  est  enfin  terminé  et  vous  devriez  avoir  un  écran  autonome qui  vous affichera déjà les information de sortie sur le port Série.

Dans cette partie, nous aborderons la partie Mapping Vidéo du projet; Rassurez-vous, cela n'a rien de bien compliqué ! Il vous suffit de vous munir du logiciel HeavyM-Live (avec licence !), d'un projecteur et de quelques tutos (disponibles sur le site) pour prendre en main le logiciel. ^^

Pour commencer, il faut créer la forme que l'on souhaite mapper. Pour obtenir la voiture d'Initial D, nous avons fait le choix de partir d'un dessin. Nous l'avons reproduit sur un tableau puis fait les dessins sur HeavyM par dessus à l'aide du vidéo projecteur. Pour cela, utilisez l'option Draw (crtl +F), et faites au mieux pour obtenir la forme desirée.

La particularité sera ensuite de séparer les parties du dessin en groupes de pièces afin de pouvoir les gérer séparément d'un point de vue mapping. Dans notre cas, nous avons voulu pouvoir sélectionner les roues, les feux, la vitre et les flammes sortant du pot d'échappement ;). Nous avons donc sélectionnés les groupes de pièces et attribués ceux-ci à des groupes de couleurs différents (voir section Groups du logiciel, en bas à droite de votre écran). Il suffit de sélectionner vos pièces et de les ajouter au groupe correspondant à l'aide des boutons + à côté. Veillez à bien ordonnez vos pièces ou vous risquez de vous y perdre.

Voici ce que nous avons réussi à faire. La forme est dessinée et les pièces sont réparties par groupes. (si vous avez du mal, le fichier HeavyM est joint pour vous permettre de vous en inspirer ;))

Il suffit maintenant de gérer les animations des groupes de pièces. Pour cela, allez dans la partie droite de votre écran et cliquez sur les icônes Border, Fill, Structure ou Transition. Une fois dans l'une d'elles, vous n'avez qu'à activer/désactiver les animations que vous souhaitez en gérant leur couleur. Pour notre part, nous utiliserons principalement les animations de Filling.

N'oubliez pas qu'il faut bien sélectionner le groupe de pièces que vous souhaitez animer avant d'interagir avec ! Chaque réglage de mapping s'effectuera en fonction du groupe.

Pour cette partie, nous devons relier le programme qui servira d'intermédiaire (Pd extended / Pure Data) avec HeavyM. Pour cela, nous allons créer une liaison Midi virtuelle à l'aide du logiciel LoopBe1.

Ce petit logiciel ne gère que ça. Il vous suffira donc dans Pure Data de sélectionner comme périphérique de sortie LoopBe1 (dans paramètres Midi) et de faire de même avec HeavyM (mais comme périphérique d'entrée). Pour cela aller dans Midi Controls et sélectionner le. La liaison devrait être établie à partir du moment où vous aurez bien sélectionné LoopBe1 dans les deux programmes.

Une fois cette connexion faite, il faudra sélectionner les commandes (sur Pd) et les sorties (sur HeavyM) afin de dire ce qui doit fonctionner dans cette liaison Midi. Je vous met ci-joint le lien d'un tuto sur la liaison Midi dans HeavyM.

https://www.youtube.com/watch?v=aB2-7jIFqxo&feature=youtu.be

Relier les informations reçues par l'arduino au logiciel HeavyM passe par l'utilisation du logiciel Pd-Extended. Il s'agit d'un logiciel facile d'utilisation et qui possède quelques tutos sur internet ainsi qu'une aide intégrée au logiciel assez bien faite. Une fois les quelques blocs de base compris, il vous sera facile de créer des blocs plus complexes et d'utiliser des blocs spéciaux pour traiter des informations compliquées.

Pour réaliser notre projet, nous avions besoin que Pd-Extended ouvre un ou plusieurs morceaux de musique. Pour cela il faut créer un dossier ou ranger des fichier audio au format .wav Il faut ensuite créer des blocs open et utiliser le chemin de rangement du fichier audio dans votre ordinateur. A l'aide de blocs moses qui dispatchent les informations sur 2 sorties en fonction de valeurs chiffrées, on affecte ainsi des valeurs à chacun des morceaux, valeurs qu'il suffit d'envoyer à Pd-Extended depuis l'arduino pour selectionner la musique voulue. Le bloc de lecture de musique fonctionne grâce à un bloc readsf qui est un outil de lecture de sons inclu dans Pd-Extended, donc pas besoin de bibliothèque supplémentaire ^^ Enfin le bloc musique permet également grâce à des valeurs envoyées de l'arduino, de régler le volume de la musqiue et de mettre en pause ou démarer les musiques.

Pour échanger des informations avec l'arduino et donc recevoir les valeurs nécessaires à la modification des valeurs de volume, play pause, les groupes de pièces selectionnées, les couleurs selectionnées ainsi que la musique choisie il faut utiliser un bloc de réception. Celui-ci est basé sur un bloc comport et démarre quand on l'active manuellement à l'aide des 2 blocs s ON_arduino et s OFF_arduino. Il faut initialiser le COM utiliser par l'arduino et également trier en listes les valeurs envoyées par l'arduino. On obtient grâce à ce bloc un s valeur_arduino qui est la donnée que l'on envoie aux autres blocs pour qu'ils puissent fonctionner.

Pour envoyer des informations au logiciel HeavyM à l'aide de la connection MIDI, en transmettant les valeurs envoyées par l'arduino il faut utiliser des blocs ctlout qu'il faut initialiser à l'aide d'interrupteurs comme vu plus haut dans l'explication de la liaison MIDI. Il est donc aisé d'envoyer des valeurs à HeavyM comme cela, nous avons par exemple défini 4 groupes de pièces ainsi que 8 couleurs comme vous le verrez ci dessous.

Le bloc de sélection des couleurs est similaire à celui des groupes de pièces, réceptionnant des valeurs de l'arduino et envoyant grâce à des blocs ctlout ces informations à HeavyM.

Voilà, le projet est maintenant terminé. Il ne reste plus qu'à attribuer les valeurs Midi entre HeavyM et Pd_extended. Pour cela, allez dans le panneau de contrôle Midi de HeavyM, et sélectionnez le groupe de pièce et l'animation ou couleur à modifier. Ensuite allez dans Pd et sélectionnez le bloc de valeurs qui agira comme contrôleur. (Veillez bien à avoir sélectionner LoopBe1 comme sortie dans Pd et comme entrée dans HeayyM.

Nous espérons que ce projet vous aura plu. ^^ Si vous souhaitez développer davantage un projet semblable, une des possibilités serait de faire agir les animations en fonction de la musique (ce ne serait plus nous qui choisirions). Pour cela, il faut davantage travailler la liaison Midi. Vous pouvez également choisir d'autres types de contrôleurs comme des manettes de ps3, un contrôleur Midi (type DJ)...

A une prochaine fois ! :p