Projet Final Prototypage : Sanjay, Ryan, Ossian

Projet Final Echiquier Pendule 

Disclaimer

Nous n’avons pas pu ajouter les fichiers d’impression 3D en raison d’une erreur survenue lors de leur téléchargement. Vous trouverez uniquement les fichiers pour la découpe laser dans ce wiki.

1. Définition du projet :

Besoin : 

Nous sommes partis de notre passion commune pour les échecs. Bien que les plateformes en ligne facilitent les parties, nous voulions retrouver l'expérience physique du jeu avec une fonctionnalité moderne : la gestion du temps de manière intégrée, sans pendule externe.

Problématique :

Les pendules électroniques pour échecs existent mais restent souvent coûteuses, peu personnalisables et séparées du plateau. Nous cherchons à concevoir une alternative plus accessible et intégrée au plateau lui-même.

Solution proposée :

Créer un échiquier physique, personnalisable et équipé d'une pendule intégrée, le tout à moindre coût, en utilisant les outils d’un FabLab (imprimante 3D, découpe laser, Arduino...).

Utilisateurs visés :

• Joueurs d’échecs amateurs ou passionnés

• Débutants curieux

• Membres de FabLabs souhaitant reproduire et améliorer ce projet open-source

Fonctionnalité principale :

• Jeu d’échecs physique avec pendule intégrée et boutons de gestion du temps

Fonctionnalités secondaires :

• Personnalisation du plateau (taille, couleurs, matériaux)

• Aimants sous les pièces pour meilleure stabilité

• Différents modes de jeu (3/2 min, 5 min, 10 min)

• LED pour indiquer la fin du temps

2. Réflexions sur la problématique & veille sur l’existant

Nous avons observé des pendules comme la DGT3000 (~80€) ou des solutions numériques externes. L’idée de les intégrer directement dans le plateau est peu exploitée. Le projet suivant nous a servi de base d’inspiration pour la partie fabrication du plateau : Un arbre, un père, un fils, une histoire

3. Lean Canvas

3. Choix techniques et Planning 

Choix Technique 

• Conception 2D / Laser : Inkscape

• Impression 3D : IdeaMaker

• Microcontrôleur : Arduino Uno

• Affichage : Écrans LCD 1602A (avec I2C)

• Matériaux : MDF 6mm, acrylique noir/blanc 3mm, plaque d’acier 1mm

• Aimants + colle chaude pour fixer les pièces

• Double face : pour coller la plaque d'acier

• Alimentation : USB / 5V

Planning de réalisation

4. Gestion de projet

MVP (Minimum Viable Product)

• Plateau avec damier

• Pièces imprimées

• Chronomètre avec deux boutons

• Affichage des temps sur le moniteur série

5. Croquis & dimensions

• Plateau : 28 cm x 28 cm

• Cases : 3,5 cm x 3,5 cm

• Pièces : taille standard imprimée 3D

• Épaisseur plateau : 6mm MDF + 1mm acier

Découpe du plateau :

Modélisation du plateau : 

Modélisation sur Inkscape : 
Pour la découpe nous avons utilisé du MPF de 6mm et utilisé les paramètre de base pour la découpe sur la machine. 

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. On a utilisé les paramètres de base de la découpe laser pour de l'acrylique de 3mm. 

6. Impression 3D des pièces et des boutons

Nous avons imprimé les pièces en 3D en utilisant Idea Maker en blanc et en noir avec une densité de 30% radeau, bordure et supports automatiquement générés :

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

Pour la pendule nous avons imprimé des boutons pour la contrôler que nous avons modéliser en 3D : 

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é. 

7. Découpe de la plaque d'acier et assemblage de l'échiquier 

Pour finir l'assemblage, nous avons découpé 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. Cette boite nous sert a camoufler tout le système électronique qui se trouvera dedans et pourquoi pas ranger les pièces quand on ne les utilise pas :

De plus une fois la boite obtenu pour fixer les boutons nous avons du imprimer des pilier support pour faire en sorte que les boutons soit maintenu a la bonne hauteur quand nous appuyons dessus. Nous avons réaliser ça grâce 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 : 

8. Résultat final de l'extérieur 

9. 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 cependant il y a une erreur de soudure car les boutons ne sont pas soudés dans le bon sens.

Voici un schéma du bon sens pour le câblage :

Code finale et montage final : 

Voici le code final complet : 

// Définition des broches
const int button1 = 2;
const int button2 = 3;
const int button5min = 4;
const int button3min = 5;
const int button10min = 6;
const int buttonStart = 7;
const int led1 = 8;
const int led2 = 9;

// Temps et état
unsigned long time1 = 0;
unsigned long time2 = 0;
unsigned long initialTime = 0;
unsigned long lastMillis = 0;

bool player1Turn = true;
bool running = false;
bool ready = false;

// Anti-rebond
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 200;

void setup() {
  pinMode(button1, INPUT_PULLUP);
  pinMode(button2, INPUT_PULLUP);
  pinMode(button5min, INPUT_PULLUP);
  pinMode(button3min, INPUT_PULLUP);
  pinMode(button10min, INPUT_PULLUP);
  pinMode(buttonStart, INPUT_PULLUP);
  pinMode(led1, OUTPUT);
  pinMode(led2, OUTPUT);

  digitalWrite(led1, LOW);
  digitalWrite(led2, LOW);

  Serial.begin(9600);
  Serial.println("Choisissez le temps, puis appuyez sur Start.");
}

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

  // Sélection du temps
  if (digitalRead(button5min) == LOW && debounce()) {
    initialTime = 5UL * 60UL * 1000UL;  // Correction ici
    resetTimers();
  } else if (digitalRead(button3min) == LOW && debounce()) {
    initialTime = 3UL * 60UL * 1000UL;  // Correction ici
    resetTimers();
  } else if (digitalRead(button10min) == LOW && debounce()) {
    initialTime = 10UL * 60UL * 1000UL;  // Correction ici
    resetTimers();
  }

  // Lancement avec Start
  if (ready && digitalRead(buttonStart) == LOW && debounce()) {
    flashBothLeds(3);
    running = true;
    lastMillis = currentMillis;
    ready = false;
    Serial.println("Départ ! Joueur 1 commence.");
  }

  // Gestion du jeu
  if (running) {
    if (digitalRead(button1) == LOW && !player1Turn && debounce()) {
      updateTime();
      player1Turn = true;
      Serial.println("Joueur 1 à toi !");
    } else if (digitalRead(button2) == LOW && player1Turn && debounce()) {
      updateTime();
      player1Turn = false;
      Serial.println("Joueur 2 à toi !");
    }

    if (currentMillis - lastMillis >= 1000) {
      lastMillis = currentMillis;
      if (player1Turn && time1 > 0) time1 -= 1000;
      if (!player1Turn && time2 > 0) time2 -= 1000;
      printTimes();
    }

    if (time1 == 0 && running) {
      Serial.println("Temps écoulé pour Joueur 1 !");
      flashLed(led1);
      running = false;
    } else if (time2 == 0 && running) {
      Serial.println("Temps écoulé pour Joueur 2 !");
      flashLed(led2);
      running = false;
    }
  }
}

void resetTimers() {
  time1 = initialTime;
  time2 = initialTime;
  running = false;
  ready = true;
  Serial.print("Temps sélectionné : ");
  Serial.print(initialTime / 60000);
  Serial.println(" min par joueur. Appuyez sur Start.");
}

void updateTime() {
  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;
}

bool debounce() {
  unsigned long current = millis();
  if (current - lastDebounceTime > debounceDelay) {
    lastDebounceTime = current;
    return true;
  }
  return false;
}

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 < 6; i++) {
    digitalWrite(ledPin, HIGH);
    delay(150);
    digitalWrite(ledPin, LOW);
    delay(150);
  }
}

void flashBothLeds(int times) {
  for (int i = 0; i < times; i++) {
    digitalWrite(led1, HIGH);
    digitalWrite(led2, HIGH);
    delay(200);
    digitalWrite(led1, LOW);
    digitalWrite(led2, LOW);
    delay(200);
  }
}

voici un exemple de retour sur le moniteur : 

Temps sélectionné : 5 min par joueur. Appuyez sur Start.
Départ ! Joueur 1 commence.
Joueur 1 : 4 min 59 sec || Joueur 2 : 5 min 0 sec
Joueur 1 : 4 min 58 sec || Joueur 2 : 5 min 0 sec
Joueur 1 : 4 min 57 sec || Joueur 2 : 5 min 0 sec
Joueur 1 : 4 min 56 sec || Joueur 2 : 5 min 0 sec
Joueur 1 : 4 min 55 sec || Joueur 2 : 5 min 0 sec
Joueur 1 : 4 min 54 sec || Joueur 2 : 5 min 0 sec
Joueur 1 : 4 min 53 sec || Joueur 2 : 5 min 0 sec
Joueur 1 : 4 min 52 sec || Joueur 2 : 5 min 0 sec
Joueur 2 à toi !
Joueur 1 : 4 min 51 sec || Joueur 2 : 4 min 59 sec
Joueur 1 : 4 min 51 sec || Joueur 2 : 4 min 58 sec

et un exemple d'une partie de trois minute qui prends fin :

Joueur 1 : 0 min 3 sec || Joueur 2 : 3 min 0 sec
Joueur 1 : 0 min 2 sec || Joueur 2 : 3 min 0 sec
Joueur 1 : 0 min 1 sec || Joueur 2 : 3 min 0 sec
Joueur 1 : 0 min 0 sec || Joueur 2 : 3 min 0 sec
Temps écoulé pour Joueur 1 !

Voici le montage final : 

10. Pistes d’amélioration

• Résoudre définitivement l'affichage I2C

• Utiliser un écran OLED ou TFT

• Miniaturiser l’électronique (passer à Arduino Nano)

• Créer un mode blitz ou Fischer avec incrément

• Boîtier plus compact

11. Sources et inspirations

• Samuel Mamias - Échiquier bois fait main

• Arduino LCD I2C : Arduino.cc tutorial

• Boxe.py (créateur de boîtes SVG)

• Stack Overflow et forums Arduino