Projet Final Prototypage : Sanjay, Ryan, Ossian

Projet Final Echiquier Pendule :

Définition du projet :

Problématique : 

Nous sommes partis de notre passion commune pour les échecs. voulant pourvoir y jouer dans le monde réel et pas juste en ligne en étant côte à côte, en attrapant les pièce maisa vec es règles de timer sans avoir a utiliser un pendue externe. Des solutions existent cependant elles sont trop coûteuse. 

Solution et cible: 

La solution que nous proposons est de créer un jeu d'échec personnalisable qui serait à moindre coût. La cible est donc les personnes vouant s'offrir a la fois un jeu peu cher mais aussi un jeu qui plairait a n'imporrte qui en le personnalisant. On s'adresse donc à tout les amoureux d'échecs ou toute personne voulant découvrir ce monde mais aussi aux personnes du FABLAB car c'est là que se fait le projet et qu'est ce wiki !

Inspirations :

Nous nous sommes inspiré du travail suivant qui est un plateau fait maison afin d'avoir une base :

disponible sur ce lien : https://www.samuelmamias.com/echiquier-un-arbre-un-pere-un-fils-une-histoire/

 

Conception et modélisation :

Nous avons commencé par la modélisation du plateau en se basant sur ce prototype : 

Puis nous l'avons fait sur Inkscape : 

En parallèle nous avons imprimé les pièces en 3D en utilisant Idea Maker :

Voici le résultat de la première impressions des pièces en blanc : 

Pour aller plus loin, nous avons l'objectif d'ajouter une pendule dans le jeu avec des boutons pour la contrôler que nous avons modéliser en 3D mais qui malheureusement ne rend pas comme souhaité : 

La première impression n'ayant pas fonctionné car nous avions pas mis assez de remplissage, le bouton n'était pas assez solide. Nous avons recommencer en changeant les paramètres avec un remplissage à 50% et cette fois tout a bien fonctionné. 

Découpe du damier : 

On a utilisé de l'acrylique blanc et noir mat de 3mm d'épaisseur pour faire le damier. On a représenté un damier a l'aide de Inkscape qu'on a télécharger sur l'imprimante laser. Chaque carré fait 3,5 cm. 

Par la suite nous nous sommes occuper de faire le board de l'échiquer avec une planche de bois de MPF de 6mm d'épaisseur en suivant le modèle présenté avant. 

Nous avons ensuite ajouté une planche en bois sous la partie qui allait contenir le damier de l'échiquer.

Puis une plaque en acier de 1mm d'épaisseur que nous avons découpé avec la machine de découpe jet d'eau : 

On a ensuite coller avec du double face la plaque d'acier sur l'échiquier. Par la suite pour avoir les pièces coller au plateau et éviter qu'elle tombe, nous avons collé sous chaque pièce un aimant grâce a un pistoler a colle. Puis coller le damier sur la plaque d'acier avec du double face également. 

En plus nous avons découpé une boite en bois avec le site Boxe.PY puis nous avons modifié les paramètres sur inskape et obtenue ceci : 

De plus une fois la boite obtenu pour fixer les boutons nous avons du imprimer des pillier support pour faire en sorte que les boutons soit maintenu a la bonne hauteur quand nous appuyons dessus. Nous avons réaliser ça grace a l'impression 3D :  

On peut voir le résultat des piliers ici une fois mise dans la boite avant l'ajout des boutons et avec le damier coller sur la plaque d'aluminium ainsi que les écrans qui nous donneront le temps restant pour chaque joueur mais nous détailleront cette partie ultérieurement dans la partie code : 

Voici le résultat final de l'extérieur : 

Electronique et code :

La majeur partie des problème se trouve dans l'électronique en effet les composants ne sont pas tous fonctionnels mais aussi les petites erreurs dans la lecture du code qui ne donnent pas le résultat prévu.

Test préliminaires :
Tout d'abord nous avons décidé de faire un premier test avec un seul écran qui fut un succès en utilisant le code et montage suivant : 

/*
  LiquidCrystal Library - Hello World

 Demonstrates the use a 16x2 LCD display.  The LiquidCrystal
 library works with all LCD displays that are compatible with the
 Hitachi HD44780 driver. There are many of them out there, and you
 can usually tell them by the 16-pin interface.

 This sketch prints "Hello World!" to the LCD
 and shows the time.

  The circuit:
 * LCD RS pin to digital pin 12
 * LCD Enable pin to digital pin 11
 * LCD D4 pin to digital pin 5
 * LCD D5 pin to digital pin 4
 * LCD D6 pin to digital pin 3
 * LCD D7 pin to digital pin 2
 * LCD R/W pin to ground
 * LCD VSS pin to ground
 * LCD VCC pin to 5V
 * 10K resistor:
 * ends to +5V and ground
 * wiper to LCD VO pin (pin 3)

 Library originally added 18 Apr 2008
 by David A. Mellis
 library modified 5 Jul 2009
 by Limor Fried (http://www.ladyada.net)
 example added 9 Jul 2009
 by Tom Igoe
 modified 22 Nov 2010
 by Tom Igoe
 modified 7 Nov 2016
 by Arturo Guadalupi

 This example code is in the public domain.

 http://www.arduino.cc/en/Tutorial/LiquidCrystalHelloWorld

*/

// include the library code:
#include <LiquidCrystal.h>

// initialize the library by associating any needed LCD interface pin
// with the arduino pin number it is connected to
const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);

void setup() {
  // set up the LCD's number of columns and rows:
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("temps ecoule");
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // print the number of seconds since reset:
  lcd.print(millis() / 1000);
}

 

Le message "temps ecoule" s'affiche et il faut régler le contraste grâce au potentiomètre. Cependant nous avons la problématique d'avoir 2 écran et l'arduino uno n'a pas assez de port pour tout connecter ainsi que les 6 boutons et les led. 

Echec de l'I2C :
Donc nous sommes passé au modèle I2C cependant c'est un échec pour l'instant car il n'y a soit rien d'afficher soit partiellement : voici le code utilisé en I2C 

#include <LiquidCrystal_I2C.h>

#include <Wire.h>

//initialize the liquid crystal library
//the first parameter is  the I2C address
//the second parameter is how many rows are on your screen
//the  third parameter is how many columns are on your screen
LiquidCrystal_I2C lcd(0x27,  16, 2);

void setup() {
  
  //initialize lcd screen
  lcd.init();
  // turn on the backlight
  lcd.backlight();
}
void loop() {
  //wait  for a second
  delay(100);
  // tell the screen to write on the top row
  lcd.setCursor(-10,1);
  // tell the screen to write “hello, from” on the top  row
  lcd.print("Hello, From");
  
}

On commence à -10 car il y a un problème sur les initialisation de l'affichage. 
Le problème majeur est que aucun des écran qui étaient a notre dispos n'affichaient quelque chose de viable en effet il y a un problème dans la gestion de l'I2C nous avons donc décidé pour l'instant de mettre la solution écran de côté et de faire afficher les temps sur l'ordinateur.

Code du temps et des boutons :

Nous avons besoin des fonctionnalités suivantes :

• Un bouton START/OFF
• Un bouton Joeur 1
  
• Un bouton Joueurr 2
  
• Un bouton de temps 5min
  
• Un bouton de temps 10min
  
• Un bouton de temps 3/2min
• 6 leds
• 2 résistances

Le problème majeur que nous rencontrons n'est pas dans l'affichage des led mais sur la gestion du compte à rebours. Car les led ne s'affiche que quand l'information 0 en temps d'un des joueurs apparait. Donc c'est la definition et le calcul de cette limite qui pose le plus problème.

Nous avons alors fait un montage simple avec juste deux boutons avec le code suivant : 
Photo du montage : 

// Projet Arduino : échiquier avec pendules (version minimale sans bouton Start)

// Définition des broches
const int button1 = 2; // Bouton joueur 1
const int button2 = 3; // Bouton joueur 2
const int led1 = 8;    // LED Joueur 1
const int led2 = 9;    // LED Joueur 2

// Variables de temps
unsigned long time1 = 5 * 60 * 1000; // 5 minutes en ms
unsigned long time2 = 5 * 60 * 1000; // 5 minutes en ms
unsigned long lastMillis = 0;
bool player1Turn = true;
bool running = true;

void setup() {
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);

  Serial.begin(9600);
  Serial.println("Partie commencée automatiquement : 5 min par joueur.");
  Serial.println("Joueur 1 à ton tour.");
  lastMillis = millis();
}

void loop() {
  unsigned long currentMillis = millis();

  if (running) {
    // Changement de tour
    if (digitalRead(button1) == LOW && !player1Turn) {
      updateTimes();
      player1Turn = true;
      printTimes();
      Serial.println("Joueur 1 à ton tour !");
      delay(300);
    }

    if (digitalRead(button2) == LOW && player1Turn) {
      updateTimes();
      player1Turn = false;
      printTimes();
      Serial.println("Joueur 2 à ton tour !");
      delay(300);
    }

    // Mise à jour toutes les secondes
    if (currentMillis - lastMillis >= 1000) {
      lastMillis = currentMillis;
      if (player1Turn && time1 > 0) time1 -= 1000;
      if (!player1Turn && time2 > 0) time2 -= 1000;
      printTimes();
    }

    // Fin de partie si un temps est écoulé
    if (time1 == 0) {
      Serial.println("Joueur 1 a perdu par temps écoulé !");
      flashLed(led1);
      running = false;
    }
    if (time2 == 0) {
      Serial.println("Joueur 2 a perdu par temps écoulé !");
      flashLed(led2);
      running = false;
    }
  }
}

void updateTimes() {
  unsigned long now = millis();
  unsigned long elapsed = now - lastMillis;
  if (player1Turn) {
    time1 = (time1 > elapsed) ? time1 - elapsed : 0;
  } else {
    time2 = (time2 > elapsed) ? time2 - elapsed : 0;
  }
  lastMillis = now;
}

void printTimes() {
  Serial.print("Joueur 1: ");
  Serial.print(time1 / 60000);
  Serial.print(" min ");
  Serial.print((time1 % 60000) / 1000);
  Serial.print(" sec || Joueur 2: ");
  Serial.print(time2 / 60000);
  Serial.print(" min ");
  Serial.print((time2 % 60000) / 1000);
  Serial.println(" sec");
}

void flashLed(int ledPin) {
  for (int i = 0; i < 10; i++) {
    digitalWrite(ledPin, HIGH);
    delay(200);
    digitalWrite(ledPin, LOW);
    delay(200);
  }
}

Cependant nous avion l'erreur suivante car le calcul de temps était mauvais : 

Partie commencée automatiquement : 5 min par joueur.
Joueur 1 à ton tour.
Joueur 1: 71582 min 18 sec || Joueur 2: 71582 min 19 sec
Joueur 1: 71582 min 17 sec || Joueur 2: 71582 min 19 sec
Joueur 1: 71582 min 16 sec || Joueur 2: 71582 min 19 sec
Joueur 1: 71582 min 15 sec || Joueur 2: 71582 min 19 sec
Joueur 1: 71582 min 14 sec || Joueur 2: 71582 min 19 sec
Joueur 1: 71582 min 13 sec || Joueur 2: 71582 min 19 sec
Joueur 1: 71582 min 12 sec || Joueur 2: 71582 min 19 sec
Joueur 2 à ton tour !

Après un nouvel essais et correction le code suivant fonctionne : 

// Projet Arduino : échiquier avec pendules (version minimale corrigée)

// Définition des broches
const int button1 = 2; // Bouton joueur 1
const int button2 = 3; // Bouton joueur 2
const int led1 = 8;    // LED Joueur 1
const int led2 = 9;    // LED Joueur 2

// Temps initial en millisecondes (5 minutes)
#define INITIAL_TIME 300000UL  // 5 * 60 * 1000

// Variables de temps
unsigned long time1 = INITIAL_TIME;
unsigned long time2 = INITIAL_TIME;
unsigned long lastMillis = 0;
bool player1Turn = true;
bool running = true;

void setup() {
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);

  Serial.begin(9600);
  Serial.println("Partie commencée automatiquement : 5 min par joueur.");
  Serial.println("Joueur 1 à ton tour.");
  lastMillis = millis();
}

void loop() {
  unsigned long currentMillis = millis();

  if (running) {
    // Indiquer le joueur actif avec LED allumée
    digitalWrite(led1, player1Turn ? HIGH : LOW);
    digitalWrite(led2, player1Turn ? LOW : HIGH);

    // Changement de tour
    if (digitalRead(button1) == LOW && !player1Turn) {
      updateTimes();
      player1Turn = true;
      printTimes();
      Serial.println("Joueur 1 à ton tour !");
      delay(300);
    }

    if (digitalRead(button2) == LOW && player1Turn) {
      updateTimes();
      player1Turn = false;
      printTimes();
      Serial.println("Joueur 2 à ton tour !");
      delay(300);
    }

    // Mise à jour toutes les secondes
    if (currentMillis - lastMillis >= 1000) {
      lastMillis = currentMillis;
      if (player1Turn && time1 > 0) time1 -= 1000;
      if (!player1Turn && time2 > 0) time2 -= 1000;
      printTimes();
    }

    // Fin de partie
    if (time1 == 0) {
      Serial.println("Joueur 1 a perdu par temps écoulé !");
      flashLed(led1);
      running = false;
    }

    if (time2 == 0) {
      Serial.println("Joueur 2 a perdu par temps écoulé !");
      flashLed(led2);
      running = false;
    }
  }
}

void updateTimes() {
  unsigned long now = millis();
  unsigned long elapsed = now - lastMillis;

  if (player1Turn) {
    time1 = (time1 > elapsed) ? time1 - elapsed : 0;
  } else {
    time2 = (time2 > elapsed) ? time2 - elapsed : 0;
  }

  lastMillis = now;
}

void printTimes() {
  Serial.print("Joueur 1: ");
  Serial.print(time1 / 60000);
  Serial.print(" min ");
  Serial.print((time1 % 60000) / 1000);
  Serial.print(" sec || Joueur 2: ");
  Serial.print(time2 / 60000);
  Serial.print(" min ");
  Serial.print((time2 % 60000) / 1000);
  Serial.println(" sec");
}

void flashLed(int ledPin) {
  for (int i = 0; i < 10; i++) {
    digitalWrite(ledPin, HIGH);
    delay(200);
    digitalWrite(ledPin, LOW);
    delay(200);
  }
}

Maintenant que le problème de temps est réglé et que les bouton fonctionne il est temps de passer à un modèle avec plus de bouton.
Nous avons alors fait un dernier tests avec tout les bouton pour vérifier la charge, ce test nous a donc montré qu'il peut y avoir des courts circuits rapide entre les gros boutons si ils sont trop proches : voici le code et le résultat :

Pour test que nos boutons fonctionnent 

const int buttons[] = {2, 3, 4, 5, 6, 7}; // Broches des boutons
const int numButtons = 6;

void setup() {
  Serial.begin(9600);
  for (int i = 0; i < numButtons; i++) {
    pinMode(buttons[i], INPUT_PULLUP);
  }
  Serial.println("Test de 6 boutons : appuyez pour voir le numéro dans le moniteur série.");
}

void loop() {
  for (int i = 0; i < numButtons; i++) {
    if (digitalRead(buttons[i]) == LOW) {
      Serial.print("Bouton ");
      Serial.print(i + 1);
      Serial.println(" appuyé !");
      delay(300); // Anti-rebond simple
    }
  }
}

Résultat : 

Test de 6 boutons : appuyez pour voir le numéro dans le moniteur série.
Bouton 2 appuyé !
Bouton 6 appuyé !
Bouton 1 appuyé !
Bouton 1 appuyé !
Bouton 1 appuyé !
Bouton 1 appuyé !
Bouton 5 appuyé !
Bouton 5 appuyé !
Bouton 5 appuyé !
Bouton 1 appuyé !
Bouton 1 appuyé !
Bouton 1 appuyé !
Bouton 4 appuyé !

Voici a quoi ressemble les boutons qui ont été soudés : 

 

Code finale :