Jouons au Simon

De Wikidebrouillard.

Version actuelle en date du 27 février 2013 à 16:47

Présentation de l'expérience

Refabriquez le célèbre jeu mémoriel Simon et testez votre mémoire en tentant de reproduire une séquence lumineuse et sonore de plus en plus longue.

Matériel

• Un ARDUINO
• Le logiciel Arduino
• 4 LED de couleurs différentes
• 8 résistances de 100kΩ
• Un buzzer
• Une Plaque de montage électrique (LABTEC)
• 12 fils électriques
• Un ordinateur

L'expérience

Le montage

Câbler le circuit imprimé en se référant à l'image ci-dessous.

Attention, les LEDs sont polarisées, c'est-à-dire qu'elles doivent être branchées dans un sens précis (au risque de les cramer). La patte la plus longue correspond au +, et l'autre au - (si vous avez coupé les pattes et ne savez plus laquelle était plus longue, le - se trouve du côté de la base qui comporte un méplat). Sur ce schéma, les longueurs de pattes ont été respectées, donc le + est toujours à droite.

Il se peut aussi que vos boutons poussoirs comportent différents types de fonctionnement (NO = Normalement Ouvert, ou NF = Normalement Fermé). Ici, nous travaillons en NO. Malheureusement, rien ne permet de le distinguer de façon universelle à l’œil nu, alors référez-vous à la doc du bouton, ou testez-le avec un ohmmètre.

Connecter maintenant le montage sur l'Arduino, en reprenant le schéma suivant :

Note : Si la lumière des LEDs n'est pas assez forte, vous pouvez changer la valeur de leur résistance de protection. À savoir, plus la résistance est faible, plus la LED brille, et inversement. Mais ne descendez pas sous 500 Ohms.

Le programme

Ci-dessous se trouve le code du jeu qu'il faudra envoyer dans le circuit de l'arduino. C'est lui qui détermine l'interaction des composants entre eux et définit le jeu.

Pour les non-initiés à la programmation informatique, il ne vous sera pas obligatoire de le comprendre : contentez-vous de le copier. Il est indispensable pour le reste de la manipulation.

//Simon

//---------------------------------------------------------
//Initialisation des LEDs et boutons poussoirs.
int led1 = 2; //LED rouge
int led2 = 3; //LED verte
int led3 = 4; //LED bleue
int led4 = 5; //LED jaune

int bouton1 = 6; //Bouton rouge
int bouton2 = 7; //Bouton vert
int bouton3 = 8; //Bouton bleu
int bouton4 = 9; //Bouton jaune

int speaker = 10; //Speaker

//Les numéros correspondent aux numéros d'entrées/sorties.
//Les 0 et 1 sont réservés aux transmissions/réceptions.

//Fréquences des sons de chaque couleur
int son[] = {261, 330, 392, 523};
//            Do,  Mi, Sol,  Do

//Tableau de séquence à jouer
int sequence[50];
//Personne ne dépasse jamais le niveau 50...

//---------------------------------------------------------
// Routine d'initialisation.
// Le setup sera appelée à chaque démarrage ou reset.

void setup()
{
  //Initialisation des entrées/sorties
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);
  pinMode(bouton1, INPUT);
  pinMode(bouton2, INPUT);
  pinMode(bouton3, INPUT);
  pinMode(bouton4, INPUT);
  pinMode(speaker, OUTPUT);
}

//---------------------------------------------------------
// Boucle principale.
// La loop tournera jusqu'à extinction ou reset.

void loop()
{
  randomSeed(analogRead(A0));

  //Attente de pression sur une touche.
  lectureBouton();

  //Témoin de lancement du jeu.
  melodieLancement();
  delay(2000);

  //Début du jeu
  boolean gameOver = false;
  int presse;
  int niveau = 0;
  while(!gameOver)
  {
    nouvelleNote(niveau); //Rajoute une note à la séquence.
    jouerSequence(niveau); //Joue la séquence

    for(int i=0; i<=niveau; i++) //Attend que le joueur tape chaque note de la séquence
    {
      presse = lectureBouton(); //Lecture du bouton appuyé par le joueur
      jouerNote(presse); //Joue la note du joueur
      if(presse!=sequence[i]) //Si la note est bonne, on continue, sinon GameOver
      {
        gameOver = true;
        melodieGameOver();
      }
      if(gameOver) {break;}
    }
    niveau++;
    delay(1000);
  }
}

//---------------------------------------------------------
//Fonction de lecture des boutons.
  //L'arduino vérifie les boutons un par un, mais comme la vitesse d'une vérification
  //est de l'ordre de la nanoseconde, l'ensemble est presque instantané.
int lectureBouton()
{
  int boutonPresse = 0;

  while(!boutonPresse)
  {
    if(digitalRead(bouton1))
    {
      boutonPresse = 1;
    }
    if(digitalRead(bouton2))
    {
      boutonPresse = 2;
    }
    if(digitalRead(bouton3))
    {
      boutonPresse = 3;
    }
    if(digitalRead(bouton4))
    {
      boutonPresse = 4;
    }
  }
  return boutonPresse;
}

//---------------------------------------------------------
//Fonction de lumière et de son
void jouerNote(int numero)
{
  switch(numero)
  {
    case 1:
      digitalWrite(led1, HIGH);
      break;
    case 2:
      digitalWrite(led2, HIGH);
      break;
    case 3:
      digitalWrite(led3, HIGH);
      break;
    case 4:
      digitalWrite(led4, HIGH);
      break;
  }
  tone(speaker, son[numero-1]); //Le tableau commence à 0 (non à 1)
  delay(800);

  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  noTone(speaker);

  delay(200);
}

//---------------------------------------------------------
//Joue toute la séquence
void jouerSequence(int niveau)
{
  for(int i=0; i<=niveau; i++)
  {
    jouerNote(sequence[i]);
  }
}

//---------------------------------------------------------
//Nouvelle note aléatoire
void nouvelleNote(int niveau)
{
  sequence[niveau] = (int)random(1,5);
}

//---------------------------------------------------------
//Témoin lancement (petite séquence lumineuse)
void melodieLancement()
{
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  tone(speaker, son[0]);
  delay(300);
  tone(speaker, son[1]);
  delay(300);
  tone(speaker, son[2]);
  delay(300);
  tone(speaker, son[3]);
  delay(300);
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  noTone(speaker);
}

//---------------------------------------------------------
//Témoin Game Over
void melodieGameOver()
{
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  tone(speaker, son[3]);
  delay(150);
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  delay(150);
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  tone(speaker, son[2]);
  delay(150);
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  tone(speaker, son[1]);
  delay(150);
  digitalWrite(led1, HIGH);
  digitalWrite(led2, HIGH);
  digitalWrite(led3, HIGH);
  digitalWrite(led4, HIGH);
  tone(speaker, son[0]);
  delay(150);
  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);
  digitalWrite(led3, LOW);
  digitalWrite(led4, LOW);
  delay(500);
  noTone(speaker);
}

• Ouvrir dès le logiciel Arduino. Une fenêtre s'ouvre comme dans la capture d'écran ci-dessous :

• Coller le code, puis l'enregistrer sur l'ordinateur.

• Brancher l'Arduino à l'ordinateur avec l'adaptateur USB.

• Cliquer sur le bouton "Téléverser" comme sur l'exemple ci-dessous.

Une fois cette étape effectuée, il ne doit pas y avoir de message d'erreur dans la partie noire du logiciel (en bas de la fenêtre). Si vous êtes dans ce cas, vérifiez que vous aviez copié proprement et complètement le code et recommencez la vérification.

Il se peut également que vous rencontriez un problème de connexion (ex : "Port série non trouvé"), auquel cas il s'agit d'un problème avec l'USB ou le Driver. Rendez-vous sur cette page pour plus d'informations.

Si aucun message d'alerte de s'affiche, c'est que le programme à bien été envoyé !

Vous venez de fabriquer votre Simon. Rendez-vous à l'étape suivante pour comprendre comment faire fonctionner le jeu !

La manipulation

• Appuyez sur n'importe quel bouton poussoir pour que le jeu démarre.

• Les LED s'allument et une petite mélodie est jouée pour annoncer le début de la partie.

• Une LED s'allume, puis c'est votre tour d'appuyer sur le bouton correspondant.

• Si c'est bon, deux LEDs s'allumeront successivement. Reproduisez la séquence, et celle-ci sera de plus en plus longue au fur et mesure que vous progresserez.

• Si vous vous trompez, les LEDs clignoteront et une autre mélodie vous annoncera que la partie est terminée.

• Appuyez à nouveau sur n'importe quel bouton pour rejouer une partie.

Astuce

Pour faire un montage propre, sans emmêler les câbles, coupez-les au plus court avec une pince coupante et une pince à dénuder. Utilisez ensuite une pince plate pour placer vos composants.

Explications

De manière simple

Pour comprendre le montage du jeu Simon, il faut imaginer que l'Arduino est une sorte de cerveau dont le fonctionnement peut être commandé, et que le montage sur la plaque est son corps.

Le code fourni permet de dire à l'Arduino de quels membres il dispose, et ce qu'il doit faire avec. Ainsi, il sait qu'il dispose de 4 LEDs et 4 boutons, et connaît les règles du jeu à appliquer.

Allons plus loin dans l'explication

Ce montage fonctionne totalement de façon "digitale" (numérique). C'est-à-dire que les branchements de l'Arduino ne comprennent que des '1'(allumé) et des '0'(éteint).

Ainsi la ligne de code digitalWrite(led1, HIGHT) permet de mettre la sortie référencée comme "led1" à '1'(hight = haut -> allumé) et inversement avec LOW (= bas -> éteint).

De la même façon, la commande digitalRead(bouton1) permet de lire l'état de l'entrée référencée comme "bouton1" et de renvoyer un '1' si elle est allumée (ici, le bouton est pressé) ou '0' si éteint (bouton non pressé).

La partie Initialisation du code permet de dire à l'Arduino quel sera le nom de chaque entrée ou sortie. Puis la fonction setup() spécifie le rôle de chaque entrée (INPUT) ou sortie (OUTPUT).

Le code est commenté (en vert) et consiste à dire à l'Arduino, quand et quelle LED allumer, et quand vérifier si un bouton à été pressé.

Si vous avez quelques bases de programmation, il est vraiment très simple à comprendre.

La gestion du speaker est relativement simple puisqu'elle se base sur la fonction tone() qui prend en paramètre la variable faisant référence au speaker et la fréquence de la note à jouer.

Ici, pour plus de simplicité, les fréquences ont été définies dans un tableau.

Du côté des branchements, les LEDs sont protégées par une résistance, de façon à éviter les surtensions (qui généralement brûlent le composant), et les boutons poussoirs sont branchés entre le 5V et l'entrée voulue, avec une résistance, dite de pull-down, qui permet d'obtenir le '1' et le '0' voulus.

Questions sans réponses

Après cette manipulation, sauriez-vous répondre à ces questions ? Elles ne sont pas bien compliquées, il suffit de revenir sur les différentes manipulations que vous venez de faire !

• Pourriez-vous créer un Simon à six touches ?

Astuce : vous aurez besoin d'ajouter des composants au circuit électronique et des instructions au code.

• Sauriez-vous créer un mode de jeu supplémentaire, permettant par exemple de jouer à plusieurs ?

Astuce : ici, seul le code a besoin d'être modifié.

Liens avec d'autres expériences

Expériences sur Wikidébrouillard

Catégorie Arduino

Autres expériences

Vous pouvez retrouver une multitude d'expériences sur l'arduino à cette adresse : http://arduino.cc/forum/index.php/topic,67634.0.html

Applications : liens avec le quotidien

L’intérêt de cette manipulation est de vous faire comprendre comment sont fabriqués les jeux que vous pouvez trouver dans le commerce : ils reposent tous sur le principe d'un circuit électronique avec lequel vous interagissez. Ainsi, lorsque vous achèterez un jeu électronique, vous serez plus à même de comprendre comment il a été conçu et fabriqué !

Catégories

Jouons au Simon