In diesem Tutorial lernst du, wie du das Game of Life auf einem 8×8 LED-Punktmatrix-Display mit dem MAX7219-Treiber und einem Arduino implementierst. Ich gebe dir auch Anleitungen und eine Umsetzung für einen ESP8266 ESP-12F Mini anstelle des Arduino. So kannst du einen ikonischen Game of Life in einem Würfel bauen, der das oben gezeigte Gleiter-Muster ausführt.
Nerdiger geht’s kaum!
Was ist das Game of Life
Das Game of Life, auch bekannt als Conway’s Game of Life, ist ein zellulärer Automat, der vom Mathematiker John Horton Conway im Jahr 1970 entwickelt wurde. Es ist kein traditionelles Spiel im Sinne von Spielern oder Gewinn- bzw. Verlustbedingungen. Stattdessen handelt es sich um eine Simulation, die einfachen Regeln folgt und komplexe Muster und Verhaltensweisen zeigt.
Das Game of Life findet auf einem Raster von Zellen statt, wobei jede Zelle entweder lebendig oder tot sein kann. Das Raster kann jede Größe haben, aber in diesem Tutorial verwenden wir ein 8×8 LED-Punktmatrix-Display. Das Spiel läuft in diskreten Zeitschritten ab, bei denen der Zustand jeder Zelle basierend auf ihrem aktuellen Zustand und dem ihrer Nachbarzellen aktualisiert wird.
Regeln
Die Regeln des Game of Life lauten wie folgt:
- Eine lebende Zelle mit weniger als zwei lebenden Nachbarn stirbt.
- Eine lebende Zelle mit zwei oder drei lebenden Nachbarn überlebt.
- Eine lebende Zelle mit mehr als drei lebenden Nachbarn stirbt.
- Eine tote Zelle mit genau drei lebenden Nachbarn wird lebendig.
Unten siehst du fünf Muster (a,… ,e) und deren Entwicklung über drei Iterationen (0,… ,2). Dieses Bild stammt aus Martin Gardner’s einer Kolumne in Scientific American, wo Conway’s Game of Life zuerst populär wurde.
Diese Regeln werden gleichzeitig auf alle Zellen im Raster angewendet, was im Laufe der Zeit faszinierende Muster und Verhaltensweisen entstehen lässt. Das Game of Life ist ein klassisches Beispiel für einen zellulären Automaten und wurde intensiv wegen seiner mathematischen Eigenschaften und seiner Fähigkeit, komplexe Systeme zu simulieren, untersucht.
Gleiter
Das bekannteste Muster im Game of Life ist der „Gleiter“. Ein Gleiter ist eine Zellkonfiguration, die sich diagonal über das Raster bewegt, während das Spiel fortschreitet. Es ist ein sich selbst replizierendes Muster, das verwendet werden kann, um andere interessante Muster und Strukturen zu erzeugen. Hier ist ein Beispiel für einen Gleiter in Bewegung:
Dies ist nur eines von vielen interessanten und komplexen Mustern (link), die im Conway’s Game of Life entstehen können. Um einige dieser Muster zu erkunden, schau dir diesen Game of Life Simulator an, der großen Spaß macht. Das Spiel fasziniert Menschen seit Jahrzehnten und hat zu bedeutender Forschung in den Bereichen Mathematik, Informatik und theoretische Biologie geführt.
Game of Life in einem Würfel
Indem du es auf einem 8×8 LED-Punktmatrix-Display mit dem MAX7219-Treiber implementierst, kannst du das Spiel auf greifbare Weise visualisieren. Unten siehst du, wie der Game of Life in einem Würfel , den wir bauen werden, aussehen wird, wenn er fertig ist.
In den nächsten Abschnitten dieses Tutorials werden wir die benötigten Komponenten, den Anschluss des Displays und den Code zur Implementierung des Game of Life erkunden.
Benötigte Komponenten
Unten findest du die benötigten Teile für dieses Projekt. Wenn du das Game of Life schnell ausprobieren und mit dem Arduino laufen lassen möchtest, dann kaufe statt des vorgeschlagenen 8×8 Punktmatrix-Displays dieses hier (link). Es ist ein größeres Modul und passt nicht in den Würfel, hat aber den Vorteil, dass du nicht löten musst.
Wenn du den Würfel bauen möchtest, benötigst du den ESP8266 ESP-12F Mini (oder ein ähnlich großes Board) und das vorgeschlagene 8×8 Punktmatrix-Display. Beachte jedoch, dass du einfache Lötarbeiten an Drähten und Pins durchführen können musst.
Arduino Uno
ESP8266 ESP-12F Mini
USB-Kabel für Arduino UNO
Dupont-Drahtset
MAX7219 8×8 Punktmatrix-LED-Display
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.
Löten des Punktmatrix-Displays
Wenn du das gelistete MAX7219 8×8 Punktmatrix-LED-Display kaufst, wirst du feststellen, dass das eigentliche 8×8 LED-Display und die Platine mit dem MAX7219-Treiber separat geliefert werden. Du musst sie löten und auf die richtige Ausrichtung achten. Wenn die Teilenummer des LED-Displays vorne ist, musst du die Platine so ausrichten, dass das Label „DISY1“ ebenfalls vorne ist. Siehe Bild unten.
Wenn du Pin-Header verwendest, ist das nicht kritisch, da du das Display später drehen kannst. Wenn du das Display jedoch direkt auf die Platine lötest, musst du das richtig machen.
Übrigens ist der MAX7219 der schwarze Chip auf der Platine. Er vereinfacht die Steuerung des 8×8 Matrix-Displays erheblich und reduziert vor allem die Anzahl der GPIO-Pins, die wir vom Arduino benötigen. Für mehr Details schau dir unser MAX7219 LED dot matrix display Arduino tutorial und vielleicht auch das Datenblatt selbst an.
Im nächsten Abschnitt zeige ich dir, wie du das Display an einen Arduino anschließt.
Anschluss des Punktmatrix-Displays
Sobald du das Display auf die Platine gelötet hast, ist der Anschluss an einen Arduino einfach. Das Bild unten zeigt die Verkabelung.
Damit ist der Anschluss des Displays an den Arduino abgeschlossen. Wenn du mehr Details zur Verkabelung der Komponenten brauchst, hier ist die vollständige Verkabelungstabelle.
| Von | Pin | Drahtfarbe | Zu | Pin |
| Arduino | 5V | Rot | Display | VCC / 5V |
| Arduino | GND | Blau | Display | GND |
| Arduino | 12 | Gelb | Display | CLK |
| Arduino | 11 | Orange | Display | DIN |
| Arduino | 10 | Grün | Display | CS |
Code für das Game of Life
In diesem Abschnitt schreiben wir den Code, der das Game of Life auf einem Arduino ausführt und das Gleiter-Muster auf dem Punktmatrix-Display anzeigt.
LedControl-Bibliothek installieren
Zur Steuerung des Displays verwenden wir die LedControl Bibliothek. Die Installation ist einfach. Gehe im Arduino IDE auf „Tools“ und dann „Manage Libraries..“:
Suche nach „LedControl“ und installiere die „LedControl library by Eberhard Fahle“. Das Bild unten zeigt, wie das nach der Installation aussieht. Dauert nur eine Sekunde.
Jetzt sind wir bereit, den Arduino-Code zu schreiben.
Arduino-Code
Schau dir zuerst den kompletten Code an, um einen Überblick zu bekommen. Die Details erkläre ich in den folgenden Abschnitten.
// 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);
}
}
Konstanten und Variablen
Wir beginnen mit dem Einbinden der notwendigen LedControl-Bibliothek und der Definition der Pins für den MAX7219-Treiber. Der CLK-Pin ist mit Pin 12 verbunden, der DIN-Pin mit Pin 11 und der CS-Pin mit Pin 10. Wir erstellen außerdem eine Instanz der LedControl Klasse mit den angegebenen Pins.
#include "LedControl.h" const byte CLK = 12; const byte DIN = 11; const byte CS = 10; LedControl lc = LedControl(DIN, CLK, CS, 0);
Als Nächstes definieren wir den Anfangszustand des Spielfelds. Das Spielfeld wird als 8×8 Raster von Zellen dargestellt, wobei jede Zelle lebendig (1) oder tot (0) sein kann. Der Anfangszustand wird in Binärnotation definiert, wobei jede Zeile ein Byte mit 8 Bits ist. Da wir 8 Zeilen haben, erhalten wir eine 8×8 Bit-Matrix, die den Dimensionen unseres 8×8 LED-Punktmatrix-Displays entspricht.
byte board[8] = {
B00000000,
B00000000,
B00010000,
B00001000,
B00111000,
B00000000,
B00000000,
B00000000,
};
Hilfsfunktionen
Wir definieren zwei Hilfsfunktionen, set_bit() und get_bit(), um einzelne Bits in einem Byte zu manipulieren. Diese Funktionen werden verwendet, um den Wert eines bestimmten Bits im Spielfeld zu setzen oder auszulesen.
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;
}
Wir definieren außerdem zwei Funktionen, set() und get(), um den Wert einer bestimmten Zelle im Spielfeld zu setzen oder auszulesen. Diese Funktionen nutzen die set_bit() und get_bit() Funktionen, um die einzelnen Bits im Spielfeld zu manipulieren.
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);
}
Anzeige- und Update-Funktionen
Die update_display() Funktion ist verantwortlich für die Aktualisierung des LED-Punktmatrix-Displays mit dem aktuellen Zustand des Spielfelds. Sie löscht das Display und setzt dann die Zeilen des Displays basierend auf den Werten im Spielfeld. Beachte, dass wir ganze Zeilen auf einmal setzen, da das einfacher und schneller ist als das Setzen einzelner Bits.
void update_display() {
lc.clearDisplay(0);
for (int i = 0; i < 8; i++) {
lc.setRow(0, i, board[i]);
}
}
Die count_neighbors() Funktion zählt die Anzahl der lebenden Nachbarn für eine gegebene Zelle im Spielfeld. Sie iteriert über die Nachbarzellen und prüft deren Werte mit der get() Funktion.
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;
}
Die update_board() Funktion aktualisiert das Spielfeld basierend auf den Regeln des Game of Life. Sie erstellt ein temporäres Spielfeld temp, um die aktualisierten Werte zu speichern. Für jede Zelle im Spielfeld zählt sie die lebenden Nachbarn mit der count_neighbors() Funktion und wendet die Regeln an, um zu bestimmen, ob die Zelle lebendig oder tot sein soll. Die aktualisierten Werte werden dann mit der set() Funktion im temporären Spielfeld gesetzt. Schließlich werden die aktualisierten Werte mit der memcpy() Funktion zurück in das originale Spielfeld kopiert.
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));
}
Setup- und Loop-Funktionen
In der setup() Funktion initialisieren wir die serielle Kommunikation für Debugging-Zwecke, deaktivieren den Shutdown-Modus des MAX7219-Treibers und löschen das Display.
void setup() {
Serial.begin(9600);
lc.shutdown(0, false);
lc.clearDisplay(0);
}
In der loop() Funktion führen wir das Game of Life für vier Schritte aus. Das liegt daran, dass die Periode des Gleiter-Musters ebenfalls 4 Schritte beträgt. Nach 4 Iterationen zeigt der Gleiter dasselbe Muster, hat sich aber diagonal um einen Schritt weiterbewegt.
Für jeden Schritt setzen wir die Helligkeit des LED-Punktmatrix-Displays. Das hebt die verschiedenen Phasen der Entwicklung des Gleiter-Musters hervor. Wenn du möchtest, dass der Gleiter mit konstanter Helligkeit angezeigt wird, kannst du das hier ändern. Der Intensitätswert reicht von 0 bis 15.
Danach aktualisieren wir das Display mit dem aktuellen Zustand des Spielfelds mit der update_display() Funktion, aktualisieren das Spielfeld mit der update_board() Funktion und warten 500 Millisekunden vor dem nächsten Schritt. Die Verzögerung dient nur dazu, den Gleiter zu verlangsamen. Auch das kannst du leicht anpassen.
void loop() {
for (int step = 0; step < 4; step++) {
lc.setIntensity(0, step);
update_display();
update_board();
delay(500);
}
}
Und das war’s! Jetzt läuft das Game of Life auf deinem Arduino. Natürlich ist das erst der Anfang. Neben dem Gleiter gibt es viele weitere interessante Muster, die du ins Programm aufnehmen könntest. Diese verschiedenen Muster könnten dann über einen Knopf, einen Drehencoder oder ein anderes Eingabegerät ausgewählt werden.
Aber alles in einem schönen Gehäuse und mit der Möglichkeit, das Gerät über eine Weboberfläche zu steuern, wäre noch viel cooler. Und genau das zeige ich dir im nächsten Abschnitt.
Wir werden die Weboberfläche nicht implementieren, aber wir verwenden den ESP8266 ESP-12F Mini, der WiFi-fähig ist, sodass wir diese Funktion später hinzufügen können. Außerdem ist der ESP8266 ESP-12F Mini ungefähr so groß wie das Punktmatrix-Display, was es uns erlaubt, alles ordentlich in einem Würfel unterzubringen.
Lass uns weitermachen und den Game of Life in einem Würfel bauen!
Einrichten des ESP8266 ESP-12F Mini
Die Kommunikation mit dem ESP8266 erfordert die Installation eines CH340-Treibers. Außerdem müssen wir das Board selbst installieren. Wie das geht, zeige ich dir in den folgenden Abschnitten.
Installation des CH340g-Treibers
Der CH340-Treiber ist die Software für einen USB-zu-Seriell-Konverter-Chip, der es dem Board ermöglicht, über USB mit dem Computer zu kommunizieren. Dieser Treiber wird häufig bei Boards verwendet, die keine eingebaute USB-Schnittstelle haben. Wir brauchen ihn, um den ESP8266 über den COM/USB-Port zu programmieren.
- Lade den Windows CH340 Driver
- Entpacke die Datei
- Führe den entpackten Installer aus
- Verbinde deinen ESP8266 mit einem USB-Kabel, und du solltest im Arduino IDE einen aktiven COM-Port sehen
Installation des ESP8266-Boards
Als Nächstes müssen wir das ESP8266-Board installieren. Gehe zu „Datei“ und „Voreinstellungen“ und gib die folgende URL in das Feld „Zusätzliche Boardverwalter-URLs“ ein:
http://arduino.esp8266.com/stable/package_esp8266com_index.json
Das Bild unten zeigt, wo du das URLs-Feld im Voreinstellungen-Dialog findest.
Dann öffne „Tools“, „Board“ und „Boardverwalter“ und installiere „esp8266 by ESP8266 Community“.
Puh, fast geschafft. Jetzt können wir mit dem Board kommunizieren sowie Sketche kompilieren und hochladen. Aber zuerst müssen wir den Code ein wenig anpassen, da der ESP8266 andere Pins als der Arduino verwendet, um mit dem LED-Display zu kommunizieren.
Pin-Konstanten und Verkabelung
Ersetze einfach die Pin-Konstanten im Code, die für den Arduino sind, durch die folgenden.
// ESP8266 ESP-12F Mini const byte DIN = 12; // D6 const byte CS = 14; // D5 const byte CLK = 13; // D7
Natürlich müssen wir jetzt auch den ESP8266 und das Punktmatrix-Display entsprechend verkabeln. Verbinde D6 mit DIN, D5 mit CS und D7 mit CLK. Schließlich verbinde die Stromversorgung (5V mit VCC und G mit GND). Im Bild unten siehst du, wie das aussehen sollte, wenn du fertig bist.
Überprüfe die Verkabelung und die neuen Pin-Konstanten, dann können wir den Game of Life-Sketch auf den ESP8266 hochladen. Die Drähte müssen an der Eingangsseite, markiert mit „-> IN“, der Display-Platine angeschlossen sein.
ESP8266-Board auswählen und Sketch hochladen
Öffne die Arduino IDE und wähle unter „Tools“, „Board“, „ESP8266“ das Board „LOLIN(WEMOS) D1 R2 and mini“ aus.
Du solltest jetzt in der Lage sein, den Sketch wie gewohnt zu kompilieren und hochzuladen. Das Display sollte dann den Gleiter über das Spielfeld kriechen lassen.
Glückwunsch! Der letzte Schritt ist, den Würfel zu bauen und alles darin unterzubringen.
Gehäuse bauen
Ich habe einen 3D-Drucker verwendet und die zwei unten gezeigten Teile gedruckt. Du kannst die STL-Dateien für die beiden Teile here herunterladen.
Das Punktmatrix-Display wird einfach (eng) in den vorderen Rahmen eingepresst, und der ESP8266 sitzt in der Mitte zwischen den beiden Teilen, mit etwas Heißkleber für zusätzliche Stabilität fixiert. Wenn du die beiden Teile zusammensteckst, bist du fertig. Die Bilder unten zeigen das komplette Gehäuse mit und ohne eingesetztes Display und Board.
Und das war’s. Ein großartig aussehendes Game of Life in einem Würfel !
Wie gesagt, das ist erst der Anfang! Wir könnten viele weitere Muster neben dem ikonischen „Gleiter“ hinzufügen. Ein ähnlich interessantes Muster ist der Lightweight Spaceship. Probier es aus:
// lightweight spaceship
byte board[8] = {
B00000000,
B00100100,
B01000000,
B01000100,
B01111000,
B00000000,
B00000000,
B00000000,
};
Und hier noch eine Idee: Mit einem Wi-Fi-fähigen Board im Würfel könnte das Gerät komplett über eine Weboberfläche gesteuert werden, inklusive der Definition neuer Muster zum Ausführen. Es liegt ganz bei dir!
Zusammenfassung
In diesem Tutorial haben wir erfolgreich das Game of Life auf einem 8×8 LED-Punktmatrix-Display mit dem MAX7219-Treiber implementiert. Wir haben zunächst verstanden, was das Game of Life ist und wie es funktioniert. Dann haben wir die benötigten Komponenten für dieses Projekt aufgelistet, darunter ein Arduino-Board, ein 8×8 LED-Punktmatrix-Display und den MAX7219-Treiber.
Anschließend haben wir den Prozess des Anschlusses des LED-Punktmatrix-Displays an das Arduino-Board mit dem MAX7219-Treiber durchlaufen. Wir haben die Verkabelung erklärt und eine klare Übersicht bereitgestellt, um dir die Arbeit zu erleichtern.
Danach sind wir in den Code für das Game of Life eingestiegen. Wir haben die Logik hinter der Implementierung erklärt und eine Schritt-für-Schritt-Anleitung zum Schreiben des Codes gegeben. Außerdem haben wir den kompletten Code zur Verfügung gestellt.
Wenn du den Anweisungen in diesem Tutorial gefolgt bist, solltest du jetzt ein funktionierendes Game of Life auf deinem LED-Punktmatrix-Display haben. Du kannst mit verschiedenen Anfangskonfigurationen experimentieren und beobachten, wie sich die Muster im Laufe der Zeit entwickeln.
Wenn du weitere Fragen oder interessante Ideen hast, hinterlasse gerne einen Kommentar.
Links
Hier einige zusätzliche Links, die du interessant oder hilfreich finden könntest.
- 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“
