Fabrication jeu de reflexe : Différence entre versions

De Movilab.org
m (Fabrication étape par étape)
m
Ligne 131 : Ligne 131 :
  
 
=== 4. Programmation ===
 
=== 4. Programmation ===
 +
 +
Nous avons de besoin plusieurs variable pour stocker pour chaque joueur le côté (bouton de la souris) et le temps (en milliseconde) du clic.
 +
 +
 +
* j1t et j2t > temps en milliseconde depuis le démarrage de l'arduino
 +
* j1c et j2c > clic gauche ou clic droit
 +
** 0 = pas de clic
 +
 +
** 1 = clic gauche
 +
** 2 = clic droit
 +
 +
 +
On en profite pour renommer les constantes correspondant aux numéros de PIN...
 +
 +
 +
Voici un 1er code
 +
<pre>
 +
 +
 +
#include <Wire.h> #include <LiquidCrystal_I2C.h>LiquidCrystal_I2C lcd(0x27,20,4);  // pinconst int r = 11; // led rougeconst int v = 12; // led vertconst int b = 13; // led bleuconst int PIN_j1g = 8; // joueur 1 clic gaucheconst int PIN_j1d = 7; // joueur 1 clic droitconst int PIN_j2g = 6; // joueur 2 clic gaucheconst int PIN_j2d = 5; // joueur 2 clic droitboolean j1g = HIGH ; // état du bouton joueur 1 clic gaucheboolean j1d = HIGH ; // état du bouton joueur 1 clic droitboolean j2g = HIGH ; // état du bouton joueur 2 clic gaucheboolean j2d = HIGH ; // état du bouton joueur 2 clic droitunsigned long j1t = 0 ; // temps joueur 1unsigned long j2t = 0 ; // temps joueur 2  unsigned int j1c = 0 ; // côté clic joueur 1unsigned int j2c = 0 ; // côté clic joueur 2void init1tour() {  j1t = 0 ;  j2t = 0 ;  j1c = 0 ;  j2c = 0 ;  j1g = HIGH ;  j1d = HIGH ;  j2g = HIGH ;  j2d = HIGH ;}void attendreClicks() {  // boucle tant que les joueurs n'ont pas tous fait leur clic  while ( j1c == 0 && j2c == 0 ) {        j1g = digitalRead(PIN_j1g);    j1d = digitalRead(PIN_j1d);    j2g = digitalRead(PIN_j1g);    j2d = digitalRead(PIN_j2d);        if (j1g == LOW && j1c == 0) { // test le clic gauche du joueur 1 s'il n'a pas déjà fait de clic      j1c = 1 ; // mémorise le clic gauche      j1t = millis() ; // mémorise le temps    }    if (j1d == LOW && j1c == 0) {      j1c = 2 ;      j1t = millis() ;    }    if (j2g == LOW && j2c == 0) {      j2c = 1 ;      j2t = millis() ;    }    if (j2d == LOW && j2c == 0) {      j2c = 2 ;      j2t = millis() ;    } }  }void afficheGagnant() {    lcd.init();  lcd.setCursor(0,0);  lcd.print("Joueur 1");  lcd.setCursor(8,0);  lcd.print("Joueur 2");  if ( j1t < j2t ) {    lcd.setCursor(1,1);    lcd.print("Gagne");    lcd.setCursor(10,1);    lcd.print("Perdu");  } else {    lcd.setCursor(1,1);    lcd.print("Perdu");    lcd.setCursor(10,1);    lcd.print("Gagne");      }    } ;  void setup() {  pinMode(r, OUTPUT);  pinMode(v, OUTPUT);  pinMode(b, OUTPUT);  pinMode(PIN_j1g, INPUT);  pinMode(PIN_j1d, INPUT);  pinMode(PIN_j2g, INPUT);  pinMode(PIN_j2d, INPUT);  lcd.init();  lcd.backlight();  lcd.setCursor(0,0);  lcd.print("Jeu de reflexe");  lcd.setCursor(0,1);  lcd.print("avec 2 joueurs");  delay(3000);  }void loop() {  init1tour() ;    lcd.init();    lcd.setCursor(0,0);  lcd.print("Go");  attendreClicks() ;    afficheGagnant() ;  delay(3000);  }
 +
 +
 +
 +
</pre>
 +
 +
On ajoute l'aspect aléatoire...
 +
 +
avec une variable qui mémorise le côté à cliquer :
 +
* gauche = 1
 +
* droit = 2
 +
 +
et on teste si les joueurs ont bien cliqué...
 +
 +
<pre>
 +
 +
/* Jeu de reflexe by David Réchatin pour OpenFactorySainté
 +
 +
This software is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
 +
 +
This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 +
See the GNU Lesser General Public License for more details.
 +
 +
You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 +
 +
*/
 +
 +
#include <Wire.h>
 +
#include <LiquidCrystal_I2C.h>
 +
LiquidCrystal_I2C lcd(0x27, 20, 4);
 +
 +
 +
// pin
 +
const int r = 11; // led rouge
 +
const int v = 12; // led vert
 +
const int b = 13; // led bleu
 +
 +
// variables du jeu
 +
const int PIN_j1g = 8; // joueur 1 clic gauche grise
 +
const int PIN_j1d = 7; // joueur 1 clic droit
 +
const int PIN_j2g = 6; // joueur 2 clic gauche noire
 +
const int PIN_j2d = 5; // joueur 2 clic droit
 +
 +
 +
boolean j1g = HIGH ; // état du bouton joueur 1 clic gauche
 +
boolean j1d = HIGH ; // état du bouton joueur 1 clic droit
 +
boolean j2g = HIGH ; // état du bouton joueur 2 clic gauche
 +
boolean j2d = HIGH ; // état du bouton joueur 2 clic droit
 +
 +
 +
unsigned long j1t = 0 ; // temps joueur 1
 +
unsigned long j2t = 0 ; // temps joueur 2
 +
 +
 +
unsigned int j1c = 0 ; // côté clic joueur 1
 +
unsigned int j2c = 0 ; // côté clic joueur 2
 +
 +
 +
int cote = 0 ;  // gauche = 1 , droit = 2
 +
 +
 +
 +
void init_tour() {
 +
  j1t = 0 ;
 +
  j2t = 0 ;
 +
  j1c = 0 ;
 +
  j2c = 0 ;
 +
 +
 +
  j1g = HIGH ;
 +
  j1d = HIGH ;
 +
  j2g = HIGH ;
 +
  j2d = HIGH ;
 +
 +
 +
  cote = random(1, 3);
 +
}
 +
 +
 +
void attendreClicks() {
 +
 +
 +
  // boucle tant que les joueurs n'ont pas tous fait leur clic
 +
  while ( j1c == 0 && j2c == 0 ) {
 +
 +
 +
    j1g = digitalRead(PIN_j1g);
 +
    j1d = digitalRead(PIN_j1d);
 +
    j2g = digitalRead(PIN_j2g);
 +
    j2d = digitalRead(PIN_j2d);
 +
 +
 +
    if (j1g == LOW && j1c == 0) { // test le clic gauche du joueur 1 s'il n'a pas déjà fait de clic
 +
      j1c = 1 ; // mémorise le clic gauche
 +
      j1t = millis() ; // mémorise le temps
 +
    }
 +
    if (j1d == LOW && j1c == 0) {
 +
      j1c = 2 ;
 +
      j1t = millis() ;
 +
    }
 +
    if (j2g == LOW && j2c == 0) {
 +
      j2c = 1 ;
 +
      j2t = millis() ;
 +
    }
 +
    if (j2d == LOW && j2c == 0) {
 +
      j2c = 2 ;
 +
      j2t = millis() ;
 +
    }
 +
  }
 +
}
 +
 +
 +
 +
void afficheGagnant() {
 +
  lcd.init();
 +
  lcd.setCursor(0, 0);
 +
  lcd.print("Joueur 1");
 +
  lcd.setCursor(8, 0);
 +
  lcd.print("Joueur 2");
 +
 +
 +
  // si erreur du joueur 1
 +
  if (j1c != cote) {
 +
    lcd.setCursor(1, 1);
 +
    lcd.print("Perdu");
 +
  }
 +
  // si erreur du joueur 2
 +
  if (j2c != cote) {
 +
    lcd.setCursor(10, 1);
 +
    lcd.print("Perdu");
 +
  }
 +
 +
 +
  // si pas d'erreur
 +
  if (j1c == cote && j2c == cote) {
 +
    // quel est le plus rapide ?
 +
    if ( j1t < j2t ) {
 +
      lcd.setCursor(1, 1);
 +
      lcd.print("Gagne");
 +
      lcd.setCursor(10, 1);
 +
      lcd.print("Perdu");
 +
    } else {
 +
      lcd.setCursor(1, 1);
 +
      lcd.print("Perdu");
 +
      lcd.setCursor(10, 1);
 +
      lcd.print("Gagne");
 +
    }
 +
  }
 +
} ;
 +
 +
 +
 +
void setup() {
 +
  pinMode(r, OUTPUT);
 +
  pinMode(v, OUTPUT);
 +
  pinMode(b, OUTPUT);
 +
  pinMode(PIN_j1g, INPUT);
 +
  pinMode(PIN_j1d, INPUT);
 +
  pinMode(PIN_j2g, INPUT);
 +
  pinMode(PIN_j2d, INPUT);
 +
 +
 +
  lcd.init();
 +
  lcd.backlight();
 +
  lcd.setCursor(0, 0);
 +
  lcd.print("Jeu de reflexe");
 +
  lcd.setCursor(0, 1);
 +
  lcd.print("avec 2 joueurs");
 +
 +
 +
  delay(3000);
 +
}
 +
 +
 +
void loop() {
 +
 +
 +
  init_tour() ;
 +
 +
 +
  lcd.init();
 +
  lcd.setCursor(0, 0);
 +
  lcd.print("Preparez vous...");
 +
  delay(1000);
 +
 +
 +
  if (cote == 1) {
 +
    lcd.setCursor(5, 1);
 +
    lcd.print("Clic gauche");
 +
  } else {
 +
    lcd.setCursor(5, 1);
 +
    lcd.print("Clic droit");
 +
  }
 +
 +
 +
  attendreClicks() ;
 +
 +
 +
  afficheGagnant() ;
 +
 +
 +
  delay(3000);
 +
 +
 +
}
 +
 +
 +
</pre>
 +
 +
 +
 +
[[Catégorie:OpenFactory Sainté]]

Version du 27 novembre 2016 à 12:20

Objectif

Fabrication d'un jeu de réflexe avec un circuit Arduino et des souris usagés.

Principe

Le jeu est basé sur l'utilisation des 2 boutons de la souris.

L'arduino affiche de manière aléatoire sur un écran LCD le bouton (gauche ou droite) sur lequel les joueurs doivent cliquer le plus rapidement possible. L'arduino indique le vainqueur et le retard des autres joueurs.


Fabrication étape par étape

1. Les souris

On commence avec 2 souris (2 joueurs).

Démontage des souris pour modifier leur circuit et leur cablâge pour récupérer les contacts des boutons.

Connexion à l'arduino pour détecter sur l'appuie sur les bontons.

  • Bouton gauche : fil vert
  • Bouton droit : fil bleu

Raccordement à l'arduino

  • Souris 1 - bouton gauche : pin 8
  • Souris 1 - bouton droit : pin 7
  • Souris 2 - bouton gauche : pin 6
  • Souris 2 - bouton droit : pin 5

2. Led RVB

Raccordement d'une LED Rouger/Vert/Bleu pour visualiser les tests...

  • Bleu : pin 13
  • Vert : pin 12
  • Rouge : pin 11

Code pour tester les boutons :

// pin
const int r = 11; // led rouge
const int v = 12; // led vert
const int b = 13; // led bleu
const int j1g = 8; // joueur 1 clic gauche
const int j1d = 7; // joueur 1 clic droit
const int j2g = 6; // joueur 2 clic gauche
const int j2d = 5; // joueur 2 clic droit

void setup() {
  pinMode(r, OUTPUT);
  pinMode(v, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(j1g, INPUT);
  pinMode(j1d, INPUT);
  pinMode(j2g, INPUT);
  pinMode(j2d, INPUT);


}


void loop() {
  if (digitalRead(j1g) == HIGH) {
    digitalWrite(r, LOW);  
  } else {
    digitalWrite(r, HIGH);
  }
  
  if (digitalRead(j1d) == HIGH) {
    digitalWrite(b, LOW);  
  } else {
    digitalWrite(b, HIGH);
  }
  
  if (digitalRead(j2g) == HIGH) {
    digitalWrite(v, LOW);  
  } else {
    digitalWrite(v, HIGH);
  }
  
  if (digitalRead(j2d) == HIGH) {
    digitalWrite(r, LOW);  
    digitalWrite(v, LOW);  
    digitalWrite(b, LOW);  
  } else {
    digitalWrite(r, HIGH);
    digitalWrite(v, HIGH);
    digitalWrite(b, HIGH);
  }
  
}


3. L'afficheur LCD

2 lignes - 16 caractères par ligne

Modèle compatible Hitachi 44780

Pour économiser des connecteurs de sortie sur l'arduino, nous utilisons en convertisseur vers bus I2C. Celui permet de passer de 7 à 2 fils la connexion de l'afficheur LCD à l'arduino.

Code pour tester l'afficheur


#include <Wire.h> 
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4);  

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Jeu de reflexe");
  lcd.setCursor(2,1);
  lcd.print("2 souris - 1 arduino");  
}


void loop() {
}



4. Programmation

Nous avons de besoin plusieurs variable pour stocker pour chaque joueur le côté (bouton de la souris) et le temps (en milliseconde) du clic.


  • j1t et j2t > temps en milliseconde depuis le démarrage de l'arduino
  • j1c et j2c > clic gauche ou clic droit
    • 0 = pas de clic
    • 1 = clic gauche
    • 2 = clic droit


On en profite pour renommer les constantes correspondant aux numéros de PIN...


Voici un 1er code



#include <Wire.h> #include <LiquidCrystal_I2C.h>LiquidCrystal_I2C lcd(0x27,20,4);  // pinconst int r = 11; // led rougeconst int v = 12; // led vertconst int b = 13; // led bleuconst int PIN_j1g = 8; // joueur 1 clic gaucheconst int PIN_j1d = 7; // joueur 1 clic droitconst int PIN_j2g = 6; // joueur 2 clic gaucheconst int PIN_j2d = 5; // joueur 2 clic droitboolean j1g = HIGH ; // état du bouton joueur 1 clic gaucheboolean j1d = HIGH ; // état du bouton joueur 1 clic droitboolean j2g = HIGH ; // état du bouton joueur 2 clic gaucheboolean j2d = HIGH ; // état du bouton joueur 2 clic droitunsigned long j1t = 0 ; // temps joueur 1unsigned long j2t = 0 ; // temps joueur 2  unsigned int j1c = 0 ; // côté clic joueur 1unsigned int j2c = 0 ; // côté clic joueur 2void init1tour() {  j1t = 0 ;  j2t = 0 ;   j1c = 0 ;  j2c = 0 ;  j1g = HIGH ;  j1d = HIGH ;  j2g = HIGH ;  j2d = HIGH ;}void attendreClicks() {  // boucle tant que les joueurs n'ont pas tous fait leur clic  while ( j1c == 0 && j2c == 0 ) {        j1g = digitalRead(PIN_j1g);    j1d = digitalRead(PIN_j1d);    j2g = digitalRead(PIN_j1g);    j2d = digitalRead(PIN_j2d);        if (j1g == LOW && j1c == 0) { // test le clic gauche du joueur 1 s'il n'a pas déjà fait de clic       j1c = 1 ; // mémorise le clic gauche      j1t = millis() ; // mémorise le temps    }    if (j1d == LOW && j1c == 0) {      j1c = 2 ;      j1t = millis() ;    }    if (j2g == LOW && j2c == 0) {      j2c = 1 ;      j2t = millis() ;    }    if (j2d == LOW && j2c == 0) {      j2c = 2 ;      j2t = millis() ;    } }   }void afficheGagnant() {    lcd.init();  lcd.setCursor(0,0);  lcd.print("Joueur 1");  lcd.setCursor(8,0);  lcd.print("Joueur 2");  if ( j1t < j2t ) {    lcd.setCursor(1,1);    lcd.print("Gagne");    lcd.setCursor(10,1);    lcd.print("Perdu");  } else {    lcd.setCursor(1,1);    lcd.print("Perdu");    lcd.setCursor(10,1);    lcd.print("Gagne");      }    } ;  void setup() {  pinMode(r, OUTPUT);  pinMode(v, OUTPUT);  pinMode(b, OUTPUT);  pinMode(PIN_j1g, INPUT);  pinMode(PIN_j1d, INPUT);  pinMode(PIN_j2g, INPUT);  pinMode(PIN_j2d, INPUT);  lcd.init();  lcd.backlight();  lcd.setCursor(0,0);  lcd.print("Jeu de reflexe");  lcd.setCursor(0,1);  lcd.print("avec 2 joueurs");  delay(3000);  }void loop() {  init1tour() ;    lcd.init();    lcd.setCursor(0,0);  lcd.print("Go");  attendreClicks() ;    afficheGagnant() ;  delay(3000);  }



On ajoute l'aspect aléatoire...

avec une variable qui mémorise le côté à cliquer :

  • gauche = 1
  • droit = 2

et on teste si les joueurs ont bien cliqué...


/* Jeu de reflexe by David Réchatin pour OpenFactorySainté
 
 This software is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
See the GNU Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20, 4);


// pin
const int r = 11; // led rouge
const int v = 12; // led vert
const int b = 13; // led bleu

// variables du jeu
const int PIN_j1g = 8; // joueur 1 clic gauche grise
const int PIN_j1d = 7; // joueur 1 clic droit
const int PIN_j2g = 6; // joueur 2 clic gauche noire
const int PIN_j2d = 5; // joueur 2 clic droit


boolean j1g = HIGH ; // état du bouton joueur 1 clic gauche
boolean j1d = HIGH ; // état du bouton joueur 1 clic droit
boolean j2g = HIGH ; // état du bouton joueur 2 clic gauche
boolean j2d = HIGH ; // état du bouton joueur 2 clic droit


unsigned long j1t = 0 ; // temps joueur 1
unsigned long j2t = 0 ; // temps joueur 2


unsigned int j1c = 0 ; // côté clic joueur 1
unsigned int j2c = 0 ; // côté clic joueur 2


int cote = 0 ;  // gauche = 1 , droit = 2



void init_tour() {
  j1t = 0 ;
  j2t = 0 ;
  j1c = 0 ;
  j2c = 0 ;


  j1g = HIGH ;
  j1d = HIGH ;
  j2g = HIGH ;
  j2d = HIGH ;


  cote = random(1, 3);
}


void attendreClicks() {


  // boucle tant que les joueurs n'ont pas tous fait leur clic
  while ( j1c == 0 && j2c == 0 ) {


    j1g = digitalRead(PIN_j1g);
    j1d = digitalRead(PIN_j1d);
    j2g = digitalRead(PIN_j2g);
    j2d = digitalRead(PIN_j2d);


    if (j1g == LOW && j1c == 0) { // test le clic gauche du joueur 1 s'il n'a pas déjà fait de clic
      j1c = 1 ; // mémorise le clic gauche
      j1t = millis() ; // mémorise le temps
    }
    if (j1d == LOW && j1c == 0) {
      j1c = 2 ;
      j1t = millis() ;
    }
    if (j2g == LOW && j2c == 0) {
      j2c = 1 ;
      j2t = millis() ;
    }
    if (j2d == LOW && j2c == 0) {
      j2c = 2 ;
      j2t = millis() ;
    }
  }
}



void afficheGagnant() {
  lcd.init();
  lcd.setCursor(0, 0);
  lcd.print("Joueur 1");
  lcd.setCursor(8, 0);
  lcd.print("Joueur 2");


  // si erreur du joueur 1
  if (j1c != cote) {
    lcd.setCursor(1, 1);
    lcd.print("Perdu");
  }
  // si erreur du joueur 2
  if (j2c != cote) {
    lcd.setCursor(10, 1);
    lcd.print("Perdu");
  }


  // si pas d'erreur
  if (j1c == cote && j2c == cote) {
    // quel est le plus rapide ?
    if ( j1t < j2t ) {
      lcd.setCursor(1, 1);
      lcd.print("Gagne");
      lcd.setCursor(10, 1);
      lcd.print("Perdu");
    } else {
      lcd.setCursor(1, 1);
      lcd.print("Perdu");
      lcd.setCursor(10, 1);
      lcd.print("Gagne");
    }
  }
} ;



void setup() {
  pinMode(r, OUTPUT);
  pinMode(v, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(PIN_j1g, INPUT);
  pinMode(PIN_j1d, INPUT);
  pinMode(PIN_j2g, INPUT);
  pinMode(PIN_j2d, INPUT);


  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Jeu de reflexe");
  lcd.setCursor(0, 1);
  lcd.print("avec 2 joueurs");


  delay(3000);
}


void loop() {


  init_tour() ;


  lcd.init();
  lcd.setCursor(0, 0);
  lcd.print("Preparez vous...");
  delay(1000);


  if (cote == 1) {
    lcd.setCursor(5, 1);
    lcd.print("Clic gauche");
  } else {
    lcd.setCursor(5, 1);
    lcd.print("Clic droit");
  }


  attendreClicks() ;


  afficheGagnant() ;


  delay(3000);


}