Dans ce tutoriel, vous apprendrez comment implémenter le Jeu de la Vie sur un écran LED matriciel 8×8 utilisant le driver MAX7219 et un Arduino. Je fournirai également des instructions et une implémentation pour un ESP8266 ESP-12F Mini en remplacement de l’Arduino. Cela vous permettra de construire un emblématique Jeu de la Vie dans un Cube qui exécute le motif planeur, montré ci-dessus.
Ça ne peut pas être plus geek que ça !
Qu’est-ce que le Jeu de la Vie
Le Jeu de la Vie, aussi appelé Jeu de la Vie de Conway, est un automate cellulaire inventé par le mathématicien John Horton Conway en 1970. Ce n’est pas un jeu traditionnel au sens où il y aurait des joueurs ou des conditions de victoire ou de défaite. C’est plutôt une simulation qui suit un ensemble de règles simples et qui montre des motifs et comportements complexes.
Le Jeu de la Vie se déroule sur une grille de cellules, où chaque cellule peut être vivante ou morte. La grille peut avoir n’importe quelle taille, mais pour ce tutoriel, nous utiliserons un écran LED matriciel 8×8. Le jeu progresse par étapes discrètes, où l’état de chaque cellule est mis à jour en fonction de son état actuel et de celui de ses cellules voisines.
Règles
Les règles du Jeu de la Vie sont les suivantes :
- Une cellule vivante avec moins de deux voisins vivants meurt.
- Une cellule vivante avec deux ou trois voisins vivants survit.
- Une cellule vivante avec plus de trois voisins vivants meurt.
- Une cellule morte avec exactement trois voisins vivants devient vivante.
Ci-dessous, vous pouvez voir cinq motifs (a,… ,e) et leur évolution sur trois itérations (0,… ,2). Cette image provient de Martin Gardner’s la rubrique dans Scientific America, où le Jeu de la Vie de Conway a été popularisé pour la première fois.
Ces règles sont appliquées simultanément à toutes les cellules de la grille, ce qui conduit à l’émergence de motifs et comportements fascinants au fil du temps. Le Jeu de la Vie est un exemple classique d’automate cellulaire et a été largement étudié pour ses propriétés mathématiques et sa capacité à simuler des systèmes complexes.
Planeur
Le motif le plus populaire dans le Jeu de la Vie est le « planeur ». Un planeur est une configuration de cellules qui se déplace en diagonale à travers la grille au fur et à mesure du jeu. C’est un motif auto-réplicatif qui peut être utilisé pour créer d’autres motifs et structures intéressants. Voici un exemple de planeur en mouvement :
C’est juste l’un des nombreux motifs intéressants et complexes (link) qui peuvent être créés dans le Jeu de la Vie de Conway. Pour explorer certains de ces motifs, jetez un œil à ce Game of Life simulateur, qui est très amusant à utiliser. Le jeu fascine les gens depuis des décennies et a conduit à des recherches importantes en mathématiques, informatique et biologie théorique.
Jeu de la Vie dans un Cube
En l’implémentant sur un écran LED matriciel 8×8 avec le driver MAX7219, vous pouvez visualiser le jeu de manière tangible. Ci-dessous, vous pouvez voir à quoi ressemblera le Jeu de la Vie dans un Cube que nous allons construire une fois terminé.
Dans les sections suivantes de ce tutoriel, nous explorerons les composants nécessaires, comment connecter l’écran, et le code nécessaire pour implémenter le Jeu de la Vie.
Composants requis
Vous trouverez ci-dessous les pièces nécessaires pour ce projet. Si vous voulez juste essayer rapidement et faire tourner le Jeu de la Vie avec un Arduino, alors au lieu d’acheter l’écran matriciel 8×8 suggéré, achetez celui-ci (link). C’est un module plus grand qui ne rentrera pas dans le cube mais a l’avantage de ne pas nécessiter de soudure.
Si vous voulez construire le cube, vous aurez besoin de l’ESP8266 ESP-12F Mini (ou une carte de taille similaire) et de l’écran matriciel 8×8 suggéré. Notez cependant que vous devrez pouvoir faire un peu de soudure simple de fils et broches.
Arduino Uno
ESP8266 ESP-12F Mini
Câble USB pour Arduino UNO
Jeu de fils Dupont
Écran LED matriciel 8×8 MAX7219
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Soudure de l’écran matriciel
Si vous achetez l’écran LED matriciel 8×8 MAX7219 listé, vous remarquerez que l’écran LED 8×8 et la carte avec le driver MAX7219 sont séparés. Vous devrez les souder et vous assurer que l’orientation est correcte. Si le numéro de pièce de l’écran LED est à l’avant, vous devez orienter la carte de sorte que l’étiquette « DISY1 » soit également à l’avant. Voir la photo ci-dessous.
Si vous utilisez des broches, ce n’est pas critique, car vous pouvez faire pivoter l’écran plus tard. Mais si vous soudez l’écran directement à la carte, il faudra bien faire attention.
Au fait, le MAX7219 est cette puce noire sur la carte. Elle simplifie grandement le contrôle de l’écran matriciel 8×8 et réduit surtout le nombre de broches GPIO nécessaires sur l’Arduino. Pour plus de détails, consultez notre MAX7219 LED dot matrix display Arduino tutorial et peut-être la fiche technique elle-même.
Dans la section suivante, je vous montrerai comment connecter l’écran à un Arduino.
Connexion de l’écran matriciel
Une fois que vous avez soudé l’écran à la carte, le connecter à un Arduino est simple. La photo ci-dessous montre le câblage.
Cela complète la connexion de l’écran à l’Arduino. Si vous avez besoin de plus de détails sur le câblage des composants, voici le tableau complet des connexions.
| De | Broche | Couleur du fil | À | Broche |
| Arduino | 5V | Rouge | Écran | VCC / 5V |
| Arduino | GND | Bleu | Écran | GND |
| Arduino | 12 | Jaune | Écran | CLK |
| Arduino | 11 | Orange | Écran | DIN |
| Arduino | 10 | Vert | Écran | CS |
Code pour le Jeu de la Vie
Dans cette section, nous allons écrire le code qui fait tourner le Jeu de la Vie sur un Arduino et affiche le motif planeur sur l’écran matriciel.
Installer la bibliothèque LedControl
Pour contrôler l’écran, nous allons utiliser la bibliothèque LedControl. L’installation est simple. Allez dans « Tools » puis « Manage Libraries.. » dans l’IDE Arduino :
Cherchez ensuite « LedControl » et installez la « LedControl library by Eberhard Fahle ». La photo ci-dessous montre à quoi cela ressemble une fois l’installation terminée. Cela ne prend qu’une seconde.
Nous sommes maintenant prêts à écrire le code Arduino.
Code Arduino
Jetez un coup d’œil rapide au code complet pour avoir une vue d’ensemble. Je détaillerai les parties dans les sections suivantes.
// Game of Life on an 8x8 Dot Matrix Display
#include "LedControl.h"
// Arduino
const byte CLK = 12;
const byte DIN = 11;
const byte CS = 10;
LedControl lc = LedControl(DIN, CLK, CS, 0);
// glider
byte board[8] = {
B00000000,
B00000000,
B00010000,
B00001000,
B00111000,
B00000000,
B00000000,
B00000000,
};
void set_bit(byte *b, byte pos, byte val) {
if (val > 0) {
*b |= (1 << pos);
} else {
*b &= ~(1 << pos);
}
}
byte get_bit(byte *b, byte pos) {
return (*b >> pos) & 0x01;
}
void set(byte *board, byte r, byte c, byte val) {
set_bit(&board[r], c, val);
}
byte get(byte *board, byte r, byte c) {
return get_bit(&board[r], c);
}
void update_display() {
lc.clearDisplay(0);
for (int i = 0; i < 8; i++) {
lc.setRow(0, i, board[i]);
}
}
int count_neighbors(byte r, byte c) {
int count = 0;
for (int rd = -1; rd <= 1; rd++) {
for (int cd = -1; cd <= 1; cd++) {
if (rd == 0 && cd == 0) continue;
int nr = (r + rd + 8) % 8;
int nc = (c + cd + 8) % 8;
count += get(board, nr, nc);
}
}
return count;
}
void update_board() {
byte temp[8];
byte alive;
for (byte r = 0; r < 8; r++) {
for (byte c = 0; c < 8; c++) {
int neighbors = count_neighbors(r, c);
if (get(board, r, c)) {
alive = !(neighbors < 2 || neighbors > 3);
} else {
alive = neighbors == 3;
}
set(temp, r, c, alive);
}
}
memcpy(board, temp, sizeof(board));
}
void setup() {
Serial.begin(9600);
lc.shutdown(0, false);
lc.clearDisplay(0);
}
void loop() {
for (int step = 0; step < 4; step++) {
lc.setIntensity(0, step);
update_display();
update_board();
delay(500);
}
}
Constantes et variables
Nous commençons par inclure la bibliothèque LedControl nécessaire et définir les broches pour le driver MAX7219. La broche CLK est connectée à la broche 12, DIN à la broche 11, et CS à la broche 10. Nous créons aussi une instance de la classe LedControl avec les broches spécifiées.
#include "LedControl.h" const byte CLK = 12; const byte DIN = 11; const byte CS = 10; LedControl lc = LedControl(DIN, CLK, CS, 0);
Ensuite, nous définissons l’état initial du plateau de jeu. Le plateau est représenté comme une grille 8×8 de cellules, où chaque cellule peut être vivante (1) ou morte (0). L’état initial est défini en notation binaire et chaque ligne est un octet de 8 bits. Comme nous avons 8 lignes, nous obtenons une matrice 8×8 bits correspondant à la dimension de notre écran LED matriciel 8×8.
byte board[8] = {
B00000000,
B00000000,
B00010000,
B00001000,
B00111000,
B00000000,
B00000000,
B00000000,
};
Fonctions auxiliaires
Nous définissons deux fonctions auxiliaires, set_bit() et get_bit(), pour manipuler des bits individuels dans un octet. Ces fonctions servent à définir ou obtenir la valeur d’un bit spécifique dans le plateau de jeu.
void set_bit(byte *b, byte pos, byte val) {
if (val > 0) {
*b |= (1 << pos);
} else {
*b &= ~(1 << pos);
}
}
byte get_bit(byte *b, byte pos) {
return (*b >> pos) & 0x01;
}
Nous définissons aussi deux fonctions, set() et get(), pour définir ou obtenir la valeur d’une cellule spécifique dans le plateau de jeu. Ces fonctions utilisent set_bit() et get_bit() pour manipuler les bits individuels dans le plateau.
void set(byte *board, byte r, byte c, byte val) {
set_bit(&board[r], c, val);
}
byte get(byte *board, byte r, byte c) {
return get_bit(&board[r], c);
}
Fonctions d’affichage et de mise à jour
La fonction update_display() est responsable de la mise à jour de l’écran LED matriciel avec l’état actuel du plateau de jeu. Elle efface l’écran puis définit les lignes de l’écran en fonction des valeurs du plateau. Notez que nous définissons des lignes entières d’un coup, car c’est plus simple et plus rapide que de définir les bits un par un.
void update_display() {
lc.clearDisplay(0);
for (int i = 0; i < 8; i++) {
lc.setRow(0, i, board[i]);
}
}
La fonction count_neighbors() compte le nombre de voisins vivants pour une cellule donnée dans le plateau. Elle parcourt les cellules voisines et vérifie leurs valeurs avec la fonction get().
int count_neighbors(byte r, byte c) {
int count = 0;
for (int rd = -1; rd <= 1; rd++) {
for (int cd = -1; cd <= 1; cd++) {
if (rd == 0 && cd == 0) continue;
int nr = (r + rd + 8) % 8;
int nc = (c + cd + 8) % 8;
count += get(board, nr, nc);
}
}
return count;
}
La fonction update_board() met à jour le plateau selon les règles du Jeu de la Vie. Elle crée un plateau temporaire temp pour stocker les valeurs mises à jour. Pour chaque cellule, elle compte les voisins vivants avec la fonction count_neighbors() et applique les règles pour déterminer si la cellule doit être vivante ou morte. Les valeurs mises à jour sont ensuite définies dans le plateau temporaire avec la fonction set(). Enfin, les valeurs mises à jour sont copiées dans le plateau original avec la fonction memcpy().
void update_board() {
byte temp[8];
byte alive;
for (byte r = 0; r < 8; r++) {
for (byte c = 0; c < 8; c++) {
int neighbors = count_neighbors(r, c);
if (get(board, r, c)) {
alive = !(neighbors < 2 || neighbors > 3);
} else {
alive = neighbors == 3;
}
set(temp, r, c, alive);
}
}
memcpy(board, temp, sizeof(board));
}
Fonctions setup et loop
Dans la fonction setup(), nous initialisons la communication série pour le débogage, désactivons le mode arrêt du driver MAX7219, et effaçons l’écran.
void setup() {
Serial.begin(9600);
lc.shutdown(0, false);
lc.clearDisplay(0);
}
Dans la fonction loop(), nous faisons tourner le Jeu de la Vie pendant quatre étapes. C’est parce que la période du motif planeur est aussi de 4 étapes. Après 4 itérations, le planeur montre le même motif mais s’est déplacé d’un pas en diagonale.
Pour chaque étape, nous réglons l’intensité de l’écran LED matriciel. Cela met en valeur les différentes phases de l’évolution du motif planeur. Si vous voulez que le planeur soit affiché avec une luminosité constante, vous pouvez modifier cela ici. La valeur d’intensité varie de 0 à 15.
Ensuite, nous mettons à jour l’écran avec l’état actuel du plateau via la fonction update_display(), mettons à jour le plateau avec la fonction update_board(), et faisons une pause de 500 millisecondes avant l’étape suivante. Ce délai sert juste à ralentir le planeur. Vous pouvez bien sûr le modifier facilement.
void loop() {
for (int step = 0; step < 4; step++) {
lc.setIntensity(0, step);
update_display();
update_board();
delay(500);
}
}
Et voilà ! Vous avez maintenant le Jeu de la Vie qui tourne sur un Arduino. Bien sûr, ce n’est que le début. En plus du planeur, il y a beaucoup d’autres motifs intéressants que vous pourriez ajouter au programme. Ces différents motifs pourraient alors être sélectionnés via un bouton, un encodeur rotatif ou un autre dispositif d’entrée.
Cependant, avoir tout cela dans un boîtier sympa et la possibilité de contrôler l’appareil via une interface web serait bien plus cool. Et c’est ce que je vais vous montrer dans la section suivante.
Nous n’implémenterons pas l’interface web, mais nous utiliserons l’ESP8266 ESP-12F Mini qui est compatible WiFi, afin de pouvoir ajouter cette fonctionnalité plus tard. De plus, l’ESP8266 ESP-12F Mini a à peu près la même taille que l’écran matriciel, ce qui nous permet de tout ranger proprement dans un cube.
Allons-y et mettons le Jeu de la Vie dans un Cube !
Configuration de l’ESP8266 ESP-12F Mini
La communication avec l’ESP8266 nécessite l’installation d’un driver CH340. Nous devrons aussi installer la carte elle-même. Je vous montrerai comment faire dans les sections suivantes.
Installation du driver CH340g
Le driver CH340 est le logiciel pour une puce convertisseur USB-série qui permet à la carte de communiquer avec l’ordinateur via USB. Ce driver est couramment utilisé sur des cartes qui n’ont pas d’interface USB intégrée. Nous en aurons besoin pour programmer l’ESP8266 via le port COM/USB.
- Téléchargez le Windows CH340 Driver
- Décompressez le fichier
- Lancez l’installateur que vous avez décompressé
- Connectez votre ESP8266 avec un câble USB et vous devriez voir un port COM actif dans l’IDE Arduino
Installation de la carte ESP8266
Ensuite, nous devons installer la carte ESP8266. Allez dans « File » puis « Preferences » et entrez l’URL suivante dans le champ « Additional Boards Manager URLs » :
http://arduino.esp8266.com/stable/package_esp8266com_index.json
La photo ci-dessous montre où trouver ce champ dans la fenêtre des Préférences.
Puis ouvrez « Tools », « Board » et « Boards Manager » et installez « esp8266 by ESP8266 Community ».
Ouf, presque fini. Nous pouvons maintenant communiquer avec la carte, compiler et téléverser des sketches. Mais d’abord, il faut modifier un peu le code, car l’ESP8266 utilisera des broches différentes de l’Arduino pour communiquer avec l’écran LED.
Constantes de broches et câblage
Remplacez simplement les constantes de broches dans le code Arduino par celles-ci.
// ESP8266 ESP-12F Mini const byte DIN = 12; // D6 const byte CS = 14; // D5 const byte CLK = 13; // D7
Bien sûr, il faut aussi câbler l’ESP8266 et l’écran matriciel en conséquence. Connectez D6 à DIN, D5 à CS et D7 à CLK. Enfin, connectez l’alimentation (5V à VCC et G à GND). Sur la photo ci-dessous, vous pouvez voir à quoi cela doit ressembler une fois terminé.
Vérifiez bien le câblage et les nouvelles constantes de broches, puis vous pouvez téléverser le sketch du Jeu de la Vie sur l’ESP8266. Les fils doivent être connectés au côté entrée, marqué « -> IN », de la carte d’affichage.
Sélectionnez la carte ESP8266 et téléversez le sketch
Ouvrez l’IDE Arduino et sous « Tools », « Board », « ESP8266 », sélectionnez la carte « LOLIN(WEMOS) D1 R2 and mini ».
Vous devriez maintenant pouvoir compiler et téléverser le sketch comme d’habitude. L’écran devrait alors afficher le planeur se déplaçant sur le plateau.
Félicitations ! La dernière étape est de construire le cube et d’y mettre tout le matériel.
Construction d’un boîtier
J’ai utilisé une imprimante 3D et imprimé les deux parties montrées ci-dessous. Vous pouvez télécharger les fichiers STL des deux parties here.
L’écran matriciel est simplement emboîté (avec un ajustement serré) dans le cadre avant et l’ESP8266 est placé au milieu entre les deux parties, fixé avec un peu de colle chaude pour plus de stabilité. En emboîtant les deux parties, c’est fini. Les photos ci-dessous montrent le boîtier complet avec et sans l’écran et la carte.
Et voilà. Un superbe Jeu de la Vie dans un Cube !
Comme je l’ai dit, ce n’est que le début ! Nous pourrions ajouter beaucoup plus de motifs en plus du célèbre « planeur ». Un motif similaire et intéressant est le Lightweight Spaceship. Essayez-le :
// lightweight spaceship
byte board[8] = {
B00000000,
B00100100,
B01000000,
B01000100,
B01111000,
B00000000,
B00000000,
B00000000,
};
Et voici une autre idée : avec une carte Wi-Fi à l’intérieur, le cube pourrait être entièrement contrôlé via une interface web, y compris la définition de nouveaux motifs à exécuter. Tout dépend de vous !
Résumé
Dans ce tutoriel, nous avons réussi à implémenter le Jeu de la Vie sur un écran LED matriciel 8×8 utilisant le driver MAX7219. Nous avons commencé par comprendre ce qu’est le Jeu de la Vie et comment il fonctionne. Ensuite, nous avons listé les composants nécessaires pour ce projet, incluant une carte Arduino, un écran LED matriciel 8×8, et le driver MAX7219.
Puis, nous avons vu comment connecter l’écran LED matriciel à la carte Arduino en utilisant le driver MAX7219. Nous avons expliqué les connexions et fourni un schéma clair pour faciliter le processus.
Ensuite, nous avons exploré le code du Jeu de la Vie. Nous avons expliqué la logique de l’implémentation et donné un guide étape par étape pour écrire le code. Nous avons aussi inclus le code complet pour référence.
En suivant les instructions de ce tutoriel, vous devriez maintenant avoir un Jeu de la Vie fonctionnel sur votre écran LED matriciel. Vous pouvez expérimenter avec différentes configurations initiales et observer l’évolution des motifs dans le temps.
Si vous avez d’autres questions ou des idées intéressantes, n’hésitez pas à laisser un commentaire.
Liens
Voici quelques liens supplémentaires que vous pourriez trouver intéressants ou utiles.
- MAX7219 LED dot matrix display Arduino tutorial
- Inventing Game of Life (John Conway) – Numberphile
- Game of Life online simulator
- Collection of interesting patterns in Game of Life
- Link Collection for Game of Life
- The fantastic combinations of John Conway’s new solitaire game « life »
