Jouons au Simon
De Wikidebrouillard.
Sommaire |
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
-
1 ARDUINO
-
Le logiciel Arduino
-
4 LED de couleurs différentes
- 8 résistances de 100kΩ
- 1 buzzer
-
1 Plaque de montage électrique (LABTEC)
-
12 fils électrique environ
-
1 ordinateur
L'expérience
Ce tutoriel se divise en deux phases :
- Le montage du circuit sur la plaque de montage
- Le chargement du programme dans l'ARDUINO via l'ordinateur
Réalisation
L’élaboration du Simon se divise en deux parties : le câblage du circuit et le chargement du programme dans l'Arduino.
Nous commencerons par le câblage :
Câblez tout d'abord le circuit imprimé en vous référant à l'image ci-dessous.
Attention, les LEDs sont polarisées, c'est à dire qu'elles doivent être branché dans un sens précis (au risque de les cramer). La patte la plus longue correspond au +, et l'autre au - (si vous avez coupez les pattes et ne savez plus laquelle était plus longue, le - se trouve du côté ou la base 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érent 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 nul, alors référencez vous à la doc du bouton, ou testez le avec un Ohmmètre.
Connectez maintenant votre montage sur l'Arduino, en reprenant le schéma suivant :
Maintenant que votre Simon est câblé, il faut lui donner son programme.
Ci-dessous se trouve le code du jeu qu'il faudra envoyer dans le circuit. C'est lui qui fait 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);
}
Ouvrez dès à présent le logiciel Arduino. Un fenêtre s'ouvre comme dans la capture d'écran ci-dessous :
Collez votre code, puis enregistrez le sur votre ordinateur.
Banchez ensuite l'Arduino à votre ordinateur avec l'adaptateur USB et cliquez 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 rien 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 !
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'appuyez sur le bouton correspondant.
• Si c'est bon, deux LEDs s'allumerons 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 connait les règles du jeu à appliquer.
De manière plus complexe
Ce montage fonctionne totalement de façon "digital" (aussi dit numérique). C'est à dire que les branchements de l'Arduino ne comprenne que des '1'(allumé) et des '0'(éteint).
Ainsi la ligne de code digitalWrite(led1, HIGHT) permet de mettre la sortie référencé 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é comme "bouton1" et de renvoyer un '1' si elle est allumé (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 crament le composant), et les boutons poussoirs sont branchés entre le 5V et l'entrée voulu, avec une résistance, dite de pull-down, qui permet d'obtenir le '1' et le '0' voulu.
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
D'autres expériences utilisant l'Arduino sont disponible dans ce wiki. Vous pouvez les retrouver ici : http://www.wikidebrouillard.org/index.php/Cat%C3%A9gorie: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é !
S'inscrire
Login
Aide
