Bonjour tout le monde ! Voilà un petit projet perso que je souhaite vous partager.
PRESENTATION
Je ne sais pas si tout le monde connait le jeu de société Simon je vais donc l'expliquer en quelques mots. Le jeu se compose de 4 lumières (Bleu Jaune Rouge et Vert) et a chaque lumière son propre son. L'ordinateur génère une séquence aléatoirement et le joueur doit la reproduire. Si il réussi on augmente le nombre de notes a reproduire sinon le joueur perds tout simplement.
Le principe est donc très simple et très prenant pour un débutant en C sur Arduino.
PRE REQUIS
Je vais donc proposer mon propre montage sur arduino et expliquer en quelques mots le code et certaines lignes très spécifiques.
Le montage suivant a donc été réalisé avec un Starter Kit arduino (seuls quelques bouton poussoir sont a rajouter il me semble).
Le nécéssaire :
L'arduino, sa breadbord et les cables (Serieux ?)
4 Leds différentes couleur (Rouge Bleue Verte et Jaune de préférence)
5 Boutons poussoir
Un buzzer
Un ou deux potentiomètre(s)
Un écran LCD
Des résistance de 220 Ohms
FONCTIONNALITES
Avant de mettre les mains dans le bordel comme on dit chez moi, je préfère exprimer les fonctionnalités finales du projet afin que vous compreniez tous.
Jouer au jeu de société (Ca parait logique ca)
Enregistrement du highscore permanent.
Possibilité d'entrer son nom quand le highscore est battu. (Bouton de la LED bleue et rouge pour faire défiler et le bouton démarrage pour valider le caractère)
NOTICE
Utiliser le bouton situé tout a droite sur le schéma pour démarrer. (Celui sans Led à ses cotés)
Lors de l'entrée du nom : Les bouton de la Led bleue et rouge servent a faire défiler les caractères. (A savoir que le caractère espace est situé après le Z pour ceux ayant un pseudo court)
Le bouton servant a démarrer sert aussi a validé les caractères du nom et à passer au l'entrée suivante.
CABLAGE
Voilà on a tout ce qu'il faut on va commencer par tout cabler. Voici le schéma de câblage a l'identique du mien. J'ai utiliser deux breadbords mais vous pouvez n'en utiliser qu'une si vous organisez bien votre travail mais moi je suis un peu bordélique et j'ai besoin de place. L'important étant de câbler les mêmes ports sur les mêmes choses car il faut être en cohérence avec le code.
Spoiler
NOTE : N'hésitez pas a rajouter un câble dans le vide depuis le port A0.
N'ayez pas peur si vous débutez c'est normal. Ce projet est déjà bien avancé donc un peu compliqué a comprendre mais on va y arriver ! Comme je l'ai dit le schéma aurait pu être bien plus optimisé mais j'ai reproduit a l'identique mon prototype sur le schéma. Avec un peu de jugeote on peu facilement compacter le tout..
Une fois le tout câblé a l'identique il faut téléverser le code que voici ci dessous sauf que ce n'est pas si simple il a une petite complication.
RESET MEMOIRE (EEPROM)
En effet le programme que je vais vous transmettre utilise l'EEPROM de l'arduino. C'est simplement une mémoire permanente sur l'arduino (Comme le disque dur sur votre PC). Le problème étant qu'il faut l'initialiser une première fois afin d'effacer les éventuelles données résiduelles présente dans celle-ci. Si vous n'avez pas compris cette partie, ce n'est pas grave vous n'aurez pas à la refaire.
Voilà la mémoire est reset a notre propres valeurs on peut maintenant téléverser le code complet du jeu ! Voilà le code.
Spoiler
#include <LiquidCrystal.h>
#include <EEPROM.h>
#define ATTENTE_DEBUT 0
#define JEU_SEQ_NOTES 1
#define LECT_SEQ_JOUEUR 2
#define FIN_DE_PARTIE 3
int Etat, erreur;
int i, bouton, nNotes = 0;
int tabNotes[100];
int bpRouge = 1;
int bpVert = 2;
int bpBleu = 3;
int bpJaune = 4;
int LedR = 5;
int LedV = 6;
int LedB = 7;
int LedJ = 8;
int Buzzer = 9;
int bpDemarrage = 10;
int appui = 0;
int appuiR;
int appuiB;
int appuiV;
int appuiJ;
int R = 1;
int B = 1;
int J = 1;
int V = 1;
int tempo = 0;
int score = 0;
int diff = 0;
int son = 1000;
int sone;
int adress = 0;
int highscoretemp;
int highscore;
int ncar = 0;
int appuihaut;
int appuibas;
int appuinext;
int alpha = 0;
int tabChar[6];
int addres1;
LiquidCrystal lcd(12, 13, A4, A3, A2, A1);
void setup() {
pinMode(bpRouge, INPUT_PULLUP);
pinMode(bpVert, INPUT_PULLUP);
pinMode(bpBleu, INPUT_PULLUP);
pinMode(bpJaune, INPUT_PULLUP);
pinMode(bpDemarrage, INPUT_PULLUP);
pinMode(LedR, OUTPUT);
pinMode(LedV, OUTPUT);
pinMode(LedB, OUTPUT);
pinMode(LedJ, OUTPUT);
pinMode(Buzzer, OUTPUT);
randomSeed(analogRead(0));
lcd.begin(16, 2);
highscore = EEPROM.read(adress);
for(i = 1; i <= 6; i++){
tabChar[i] = EEPROM.read(i);
}
Etat = ATTENTE_DEBUT;
}
void name() {
int car;
noTone(Buzzer);
lcd.clear();
lcd.blink();
alpha = 0;
car = 'A';
ncar = 0;
while (ncar < 6) {
lcd.setCursor(ncar, 0);
lcd.print((char)(car));
do {
appuihaut = digitalRead(bpBleu);
appuibas = digitalRead(bpRouge);
appuinext = digitalRead(bpDemarrage);
} while ((appuihaut == 1) && (appuibas == 1) && (appuinext == 1));
if (appuihaut == 0) {
alpha++;
if (alpha == 27) {
alpha = 0;
}
}
if (appuibas == 0) {
alpha--;
if (alpha < 0) {
alpha = 26;
}
}
if( alpha == 26)
car = ' ';
else
car = 'A' + alpha;
if (appuinext == 0) {
tabChar[ncar+1] = car;
ncar++;
}
delay(250);
}
}
void AttenteDebut() {
lcd.clear();
lcd.print("loading");
delay(500);
lcd.print(".");
delay(500);
lcd.print(".");
delay(500);
lcd.print(".");
for (i = 0; i <= 100; i++) {
tabNotes[i] = random(1, 5);
}
nNotes = 0;
score = 0;
diff = 500;
son = 1000;
sone = 1000;
// to do : jouer une petite musique d'introduction (non décrit ici)
for (i = 0; i < 3; i++) {
digitalWrite(LedJ, HIGH);
delay(100);
digitalWrite(LedV, HIGH);
delay(100);
digitalWrite(LedR, HIGH);
delay(100);
digitalWrite(LedB, HIGH);
delay(100);
digitalWrite(LedJ, LOW);
delay(100);
digitalWrite(LedV, LOW);
delay(100);
digitalWrite(LedR, LOW);
delay(100);
digitalWrite(LedB, LOW);
delay(100);
}
lcd.clear();
lcd.print(" READY");
lcd.setCursor(0, 1);
lcd.print(" --------------");
for (i = 0; i < 200; i++) {
sone = sone + 100;
tone(Buzzer, sone);
delay(10);
if ( digitalRead(bpDemarrage) == LOW)
break;
}
noTone(Buzzer);
do {
appui = digitalRead(bpDemarrage);
} while (appui == 1);
delay(1000);
}
void JouerSequence() {
for (i = 0; i < nNotes; i++)
{
// to do : jouer tabNotes[i] (non décrit ici)
switch (tabNotes[i]) {
case 1 : digitalWrite(LedR, HIGH);
tone(Buzzer, 500);
break;
case 2 : digitalWrite(LedV, HIGH);
tone(Buzzer, 1500);
break;
case 3 : digitalWrite(LedB, HIGH);
tone(Buzzer, 1000);
break;
case 4 : digitalWrite(LedJ, HIGH);
tone(Buzzer, 2000);
break;
}
delay(diff);
noTone(Buzzer);
digitalWrite(LedR, LOW);
digitalWrite(LedV, LOW);
digitalWrite(LedB, LOW);
digitalWrite(LedJ, LOW);
if (score >= 5) {
diff = 400;
}
if ( score >= 10) {
diff = 250;
}
delay(diff);
}
}
void LireSequence() {
erreur = 0;
for (i = 0; i < nNotes; i++) // boucle sur le nombre courant de notes jouées
{
do {
appuiR = digitalRead(bpRouge);
appuiB = digitalRead(bpBleu);
appuiV = digitalRead(bpVert);
appuiJ = digitalRead(bpJaune);
} while ((appuiR == 1) && (appuiB == 1) && (appuiV == 1) && (appuiJ == 1));
if (appuiR == 0) {
tempo = 1;
digitalWrite(LedR, HIGH);
tone(Buzzer, 500);
}
else if (appuiB == 0) {
tempo = 3;
digitalWrite(LedB, HIGH);
tone(Buzzer, 1000);
}
else if (appuiV == 0) {
tempo = 2;
digitalWrite(LedV, HIGH);
tone(Buzzer, 1500);
}
else if (appuiJ == 0) {
tempo = 4;
digitalWrite(LedJ, HIGH);
tone(Buzzer, 2000);
}
if ( tempo != tabNotes[i] )
{
erreur = 1;
score--;
break;
}
delay(500);
noTone(Buzzer);
digitalWrite(LedR, LOW);
digitalWrite(LedV, LOW);
digitalWrite(LedB, LOW);
digitalWrite(LedJ, LOW);
}
delay(1500);
score++;
}
void FinirPartie() {
if (score > highscore) {
highscore = score;
EEPROM.write(adress, highscore);
lcd.clear();
lcd.print("NEW HIGHSCORE !!!");
delay(1000);
name();
for(i = 1; i <= 6; i++){
EEPROM.write(i, tabChar[i]);
}
}
noTone(Buzzer);
for (i = 0; i < 5; i++) {
digitalWrite(LedR, HIGH);
digitalWrite(LedV, HIGH);
digitalWrite(LedB, HIGH);
digitalWrite(LedJ, HIGH);
delay(50);
digitalWrite(LedR, LOW);
digitalWrite(LedV, LOW);
digitalWrite(LedB, LOW);
digitalWrite(LedJ, LOW);
delay(50);
}
for (i = 0; i < 250; i++) {
son = son - 5;
tone(Buzzer, son);
delay(10);
}
lcd.clear();
lcd.print(" GAME OVER");
lcd.setCursor(0, 1);
lcd.print(" Score : ");
lcd.print(score);
delay(2000);
lcd.clear();
lcd.print(" GAME OVER");
lcd.setCursor(0, 1);
lcd.print(" Highscore by ");
delay(2000);
lcd.clear();
lcd.print(" GAME OVER");
lcd.setCursor(0, 1);
lcd.print(" ");
for (i = 1; i <= 6; i++) {
lcd.print((char)(tabChar[i]));
}
lcd.print(" ");
lcd.print(highscore);
delay(2000);
noTone(Buzzer);
}
void loop() {
lcd.clear();
lcd.print("Score : ");
lcd.print(score);
lcd.setCursor(0, 1);
lcd.print("HighScore : ");
lcd.print(highscore);
int Prochain_Etat; // variable temporaire pour ne pas interférer entre l'évaluation de l'état
// par le switch et la modification de l'état selon les transitions validées
switch ( Etat )
{
case ATTENTE_DEBUT : AttenteDebut(); //on sort de la fonction quand la demande de partie survient
Prochain_Etat = JEU_SEQ_NOTES;
break;
case JEU_SEQ_NOTES : nNotes = nNotes + 1; // activité d'entrée dans l'état
JouerSequence(); // on joue la séquence une fois
Prochain_Etat = LECT_SEQ_JOUEUR;
break;
case LECT_SEQ_JOUEUR : LireSequence(); // on sort de la fonction quand une erreur survient ou
// si la séquence complète à été lue correctement
if ( erreur == 1) {
Prochain_Etat = FIN_DE_PARTIE;
}
else
Prochain_Etat = JEU_SEQ_NOTES;
break;
case FIN_DE_PARTIE : FinirPartie();
Prochain_Etat = ATTENTE_DEBUT;
break;
}
Etat = Prochain_Etat;
}
Si votre câblage est bien réalisé le jeu devrait normalement marcher.
EXPLICATIONS
Un peu d'explication techniques niveau code et cablage.
Bon déjà le câble depuis A0 dans le vide c'est pour un aléatoire meilleur. En effet si certains ont pris le temps de lire le code j'ai utiliser cette ligne particulièrement :
randomSeed(analogRead(0));
Cela permet simplement de set la "graine" d'aléatoirement sur la tension présente aux bornes du port A0. Celle-ci sera toujours différentes en fonction des ondes autour de cette broche et nous avons donc un aléatoire parfait contrairement au random() basique.
Les lignes EEPROM. Elles sont simple mais méritent le détour. C'est ces instructions qui perment la sauvegarde et la lecture en mémoire par le biais d'adresses. Cela sert donc a la sauvegarde du score et du nom d'utilisateur.
A quelques endroits du code on peut remarquer cette structure :
do {
appui = digitalRead(bpDemarrage);
} while (appui == 1);
Elle est connue de la plupart des utilisateur avancé mais vaut le détour aussi. C'est simplement une boucle bloquante attendant l'appui sur un bouton (ici le bouton de démarrage) Certains n'aiment pas ce genre de structure car elle est bloquante.
Les commandes lcd sont classiques elles aussi mais je préfère les expliquer un peu.
Les plus utilisées sont celles-ci :
lcd.print();
lcd.clear();
lcd.setCursor();
Le lcd.print affiche du texte a l'écran. NOTE : Si ce n'est pas une variable le texte ets entre double quote. lcd.print(" MON TEXTE")
Le lcd.clear() efface tout ce qui est affiché a l'écran.
Le lcd.setCursor est plus complexe au début. Il permet de dire ou il faut écrire le texte qui va suivre cette instruction.
Voilà un peu ce travail m'as pris un peu de temps mais j'en ai pris de plaisir personnel et je souhaiter le partager. Les remarques sont les bienvenue en tout termes (optimisation code ect..) Bien évidemment vous pouvez utiliser tout ce qui est présent ci-dessus sans permission de ma part sinon je ne le mettrai pas a disposition ^^.
De même si vous souhaitez des explications sur certaines parties ou si des choses ne sont pas claires je suis disponible !
