Flappy Bird ist dabei ein sehr simples Spiel. Gesteuert wird die Spielfigur am Smartphone durch Tippen auf eine beliebige Stelle des Touchscreens. Das eignet sich ideal zur Umsetzung am Arduino, da neben dem Display nur ein Pushbutton benötigt wird.

Meine einfache Implementierung entspricht vom Verhalten her sicher nicht 1:1 dem Original, aber der Programmcode ist einfach zu verstehen und kann leicht an eigene Bedürfnisse (Schwierigkeitsgrad, Erweiterung um Buzzer für Soundeffekte) angepasst werden.

Hardware-Anforderungen

Das Das Projekt stellt minimale Anforderungen an die Hardware, mit einem Arduino Uno R3 (oder kompatiblem Klon), einem kleinen OLED Display mit SSD1306-Controller und einem Pushbutton ist man schon dabei.

Für den Nachbau werden folgende Komponenten benötigt:

• OLED I2C Display 128×64 mit SSD1306 (separat erhältlich, z.B. hier im 3er Pack bei Amazon)

und die folgende Teile, die in jedem Arduino Starter Kit enthalten sind:

• Arduino UNO R3 (oder kompatibel) mit Breadboard
• Push-Buttonsfür die Steuerung
• Ein paar Kabel zur Verbindung der Komponenten

Verkabelung am Breadboard

Der Arduino Sketch und ein paar Anmerkungen

Den kompletten Quellcode findest du gut dokumentiert hier auf Github https://github.com/adidax/oled-flappy-bird-arduino/tree/main

Mit einem Arduino Uno R3 (oder kompatibel) und bei korrektem Aufbau der Schaltung am Breadboard sollte der Sketch ohne Änderungen funktionieren. Solltest du ein anderes Arduino Modell oder eine andere Belegung der Pins verwenden, dann sind eventuell kleine Anpassungen notwendig.

Der Sketch ist zwar gut dokumentiert, hier aber trotzdem ein paar kurze Anmerkungen zur Struktur.

Gleitkommafrei durch Skalierung

Wie schon beim ähnlichen Projekt Retro Racer werden auch hier alle Koordinaten am Spielfeld um den Faktor 10 hochskaliert und mit dem Datentyp int gespeichert. Damit können aufwändige Gleitkomma-Berechnungen vermieden werden, aber Spielmechaniken wie eine Änderung der Spielposition um 0,5 Pixel pro Frame sind trotzdem möglich. Das Display hat im Programmcode also nicht 128×64, sondern 1280×640 Pixel. Vor der Darstellung auf dem Display werden die Werte dann durch 10 geteilt, um diese auf die Koordinaten des OLED umzurechnen.

Fixe Framerate für gleichmäßigen Spielablauf

Damit das Spiel auf dem Arduino gleichmäßig läuft, wird versucht mit einer festen Bildwiederholrate von 25 FPS zu arbeiten. Das heißt: Die loop()-Funktion berechnet und zeichnet nur dann ein neues Frame, wenn mindestens 40 Millisekunden seit dem letzten vergangen sind:

const int FRAME_TIME = 40; // 40 ms per frame = 25 FPS
if (millis() - lastFrameTime < FRAME_TIME) return;
lastFrameTime = millis();

Das verhindert Timing-Probleme und sorgt dafür, dass Bewegung und Spielgeschwindigkeit stets konstant bleiben, unabhängig davon, wie schnell der Mikrocontroller gerade rechnet. Sollte die Berechnung und Ausgabe eines Frames länger als 40ms dauern, dann kommt es aber natürlich trotzdem zu Unregelmäßigkeiten im Ablauf. Das dürfte hier aber nicht der Fall sein.

Spielfigur fliegt bei Knopfdruck

Die Steuerung ist einfach. Pro Frame erhöht sich die Sinkgeschwindigkeit der Spielfigur um den Wert von GRAVITY und der Vogel bewegt sich nach unten. Wird der Pushbutton gedrückt, dann steigt der Vogel um den Wert von JUMP_STRENGTH und bewegt sich nach oben.

        // Wenn Button gedrückt, negative Beschleunigung (nach oben) addieren
        if (digitalRead(BUTTON_PIN) == LOW) {
            velocity = JUMP_STRENGTH;
        }
        velocity += GRAVITY; // Schwerkraft anwenden (positiver Wert = nach unten)
        velocity = constrain(velocity, -50, 50); // Begrenzung, damit Spielfigur nicht zu schnell fällt oder steigt

        // Position des Spielers berechnen
        birdY += velocity;

So entsteht das typische “Flap”-Gefühl mit steigender und fallender Bewegung.

Gnädige Kollisionsabfrage: 

Die Spielfigur ist rund, die Hitbox zur Kollisionsabfrage aber rechteckig. Daher habe ich bei der Berechnung der möglichen Kollision einen kleinen Spielraum von 2px berücksichtig.

if ((birdY - 2 * SCALE_FACTOR) < pipes[i].height || 
    (birdY + 2 * SCALE_FACTOR) > pipes[i].height + PIPE_GAP)

Damit fühlt sich das Spiel deutlich fairer an, die Spielfigur kann auch an einem Rohr „anstreifen“, ohne sofort eine Kollision zu melden.

Vorbereitung der Spielgrafik

Da das OLED-Display nur Schwarz-Weiß-Grafiken unterstützt, müssen Bilder in ein passendes Bitmap-Format umgewandelt und im Programmcode eingebunden werden. Dafür habe ich das kostenlose Online-Tool Image2CPP verwendet.

Schritt-für-Schritt-Anleitung für eigene Grafiken:

1. Lade das gewünschte PNG-Bild hoch.
2. Stelle die Bildgröße passend zur benötigten Pixelgröße ein (z. B. 10×8 Pixel für ein Auto).
3. Wähle als Ausgabeformat → Arduino Code.
4. Kopiere den generierten PROGMEM-Code in das Arduino-Projekt.
5. Nutze display.drawBitmap(x, y, bitmap, width, height, SSD1306_WHITE); zur Anzeige des Bildes.

Diese Methode ermöglicht es, eigene Icons oder Sprites für das Spiel zu erstellen und ins Flash-Speicher (PROGMEM) des Arduino zu laden. Dabei muss man aber immer beachten, dass der Speicherplatz des Arduino sehr begrenzt ist :)

Spielprinzip und Steuerung

• Die Spielfigur (ein Vogel) fliegt von links nach rechts durch das Bild. Die Flughöhe des Vogels verringert sich laufend durch die Schwerkraft, der Spieler kann über den Drucktaster einen Flügelschlag auslösen, welcher die Flughöhe wieder erhöht.
• Gleichzeitig bewegen sich die Rohre als Hindernisse auf den Vogel zu. Die Spielfigur muss durch die Lücken in den Rohren gesteuert werden.
• Kollidiert der Spieler mit einem Hindernis, ist das Spiel vorbei.
• 3 Sekunden nach Game over wird die Highscore-Liste angezeigt.
• Ein Druck auf eine beliebige Taste startet das Spiel neu.

Was mir am Projekt gefällt

Wie schon beim Retro Racer sieht man auch bei dieser Flappy Bird Variante, wie man klassische Spielideen mit einfachster Hardware und etwas Programmcode nachbauen kann und damit ein vollständiges, unterhaltsames Spiel entsteht. Die Kombination aus Spielphysik, Animation und einfachster Steuerung macht Flappy Bird zum perfekten Arduino-Projekt, egal ob zum Lernen, Lehren oder einfach zum Spaß.

Den kompletten Quellcode findest du gut dokumentiert hier auf Github https://github.com/adidax/oled-flappy-bird-arduino/tree/main

Trotz des einfachen Aufbaus des Projekts zu geringen Kosten ist das Ergebnis recht spannend und eignet sich auch gut für Gruppenprojekte, z.B. in der Schule.

Hardware-Anforderungen

Neben dem Arduino samt Breadboard, das in vielen Starter Kits enthalten ist, benötigt man lediglich ein zusätzliches OLED-Display mit SSD1306-Controller sowie zwei Push-Buttons für die Steuerung. Ein optionaler Buzzer sorgt für Soundeffekte.

Für den Nachbau werden folgende Komponenten benötigt:

• OLED I2C Display 128×64 mit SSD1306 (separat erhältlich, z.B. hier im 3er Pack bei Amazon)

und die folgende Teile, die in jedem Arduino Starter Kit enthalten sind:

• Arduino UNO R3 (oder kompatibel) mit Breadboard
• Zwei Push-Buttons für die Steuerung (links/rechts)
• Optionaler Buzzer für Soundeffekte
• Ein paar Kabel zur Verbindung der Komponenten

Verkabelung:

Der Buzzer an D6 kann auch einfach weggelassen werden, im Programmcode sind dazu keine Änderungen notwendig.

Arduino Programmcode und technische Besonderheiten

Der komplette Quellcode ist gut dokumentiert auf GitHub (oled_racer_de.ino) verfügbar. Am einfachsten beim grünen Button rechts oben „Download ZIP“ wählen und entpacken – oder den Sketch einfach über die Zwischenablage in ein neues Arduino Programmfenster kopieren.

Einige wichtige Aspekte zum Verständnis des Codes:

Optimierung durch Integer-Skalierung: 

Rechenoperationen mit Gleitkommazahlen sind aufwändig und das wollte ich vermeiden. An manchen Stellen, zum Beispiel bei der Geschwindigkeit des Spielerautos, braucht man aber die Möglichkeit, diese in feineren Schritten zu erhöhen. Deswegen habe ich Koordinaten von Objekten am Display und Geschwindigkeiten um den Faktor 10 hochskaliert und als int gespeichert. Das Display hat also im Programmcode nicht 128×64, sondern 1280×640 Pixel. So sind präzisere Berechnungen ohne Performance-Einbußen durch Float-Operationen möglich. Vor der Darstellung auf dem Display werden die Werte dann durch 10 geteilt.
Beispiel:
playerSpeed = 25 bedeutet eine Bewegung von 2.5 Pixeln pro Frame.
Ein Hindernis mit x = 150 befindet sich an Position x = 15.0 auf dem Display.

Spielzustände verwalten: 

Der Code nutzt eine enum GameState, um zwischen den verschiedenen Zuständen zu wechseln:
STARTSCREEN: Intro-Animation mit Titel.
PLAYING: Das eigentliche Spiel läuft (oder zeigt „Game over an“)
HIGHSCORE: Nach Game Over wird eine Highscore-Liste angezeigt.
Dadurch bleibt der Code sauber strukturiert und einfach erweiterbar.

Flüssige Animationen mit Timer-Steuerung: 

Das Spiel nutzt millis(), um eine konstante Framerate von 25 FPS zu halten. Statt delay() wird der Zeitunterschied zum letzten Frame berechnet, sodass die Spiellogik immer genau zur richtigen Zeit aktualisiert wird.

Adaptive Gegner-Spawns: 

Die Gegner (Hindernisse) erscheinen mit steigender Spielzeit immer häufiger. Zu Beginn gibt es nur einen Gegner gleichzeitig, später bis zu zehn, je nach zurückgelegter Distanz.

Blinkende Highscore-Anzeige: 

Falls der aktuelle Score in die Top-10 kommt, wird dieser blinkend hervorgehoben.

Vorbereitung der Spielgrafik

Da das OLED-Display nur Schwarz-Weiß-Grafiken unterstützt, müssen Bilder in ein passendes Bitmap-Format umgewandelt und im Programmcode eingebunden werden. Dafür habe ich das kostenlose Online-Tool Image2CPP verwendet.

Schritt-für-Schritt-Anleitung für eigene Grafiken:

1. Lade das gewünschte PNG-Bild hoch.
2. Stelle die Bildgröße passend zur benötigten Pixelgröße ein (z. B. 10×8 Pixel für ein Auto).
3. Wähle als Ausgabeformat → Arduino Code.
4. Kopiere den generierten PROGMEM-Code in das Arduino-Projekt.
5. Nutze display.drawBitmap(x, y, bitmap, width, height, SSD1306_WHITE); zur Anzeige des Bildes.

Diese Methode ermöglicht es, eigene Icons oder Sprites für das Spiel zu erstellen und ins Flash-Speicher (PROGMEM) des Arduino zu laden. Dabei muss man aber immer beachten, dass der Speicherplatz des Arduino sehr begrenzt ist :)

Spielprinzip und Steuerung

• Der Spieler kann sich mit den beiden Buttons nach links und rechts bewegen.
• Gegner erscheinen zufällig auf den Spuren und bewegen sich auf den Spieler zu.
• Kollidiert der Spieler mit einem Hindernis, ist das Spiel vorbei.
• 3 Sekunden nach Game over wird die Highscore-Liste angezeigt.
• Ein Druck auf eine beliebige Taste startet das Spiel neu.

Was mir am Projekt gefällt

Dieses kleine Projekt zeigt, dass auch mit begrenzten Ressourcen spannende Retro-Spiele auf dem Arduino möglich sind. Der Code ist modular und halbwegs verständlich – auf Objektklassen oder komplexere Konstrukte habe ich bewusst verzichtet – und kann leicht verändert oder erweitert werden – beispielsweise mit mehr Soundeffekten oder zusätzlichen Hindernissen.

Der komplette Quellcode ist auf GitHub verfügbar. Viel Spaß beim Nachbauen!

Besonders das 1602 Display mit 2 Zeilen à 16 Zeichen ist in fast jedem Arduino Starter Kit zu finden. Diese Displays sind praktisch und kostengünstig, haben jedoch einen Nachteil: Sie werden standardmäßig parallel angesteuert und benötigen dadurch mindestens 6 Digitalpins am Arduino und eventuell auch noch eine Potentiometer am Breadboard.

Das kann problematisch werden, wenn weitere Sensoren oder Module angeschlossen werden sollen. Hinzu kommt der Kabelsalat auf dem Breadboard, der bei komplexeren Projekten schnell unübersichtlich wird.

Die Lösung: Die I²C-Schnittstelle für LCD Displays

Die I²C-Schnittstelle (Inter Integrated Circuit) bietet eine einfache Lösung für dieses Problem. I²C ist ein Protokoll zur seriellen Kommunikation zwischen elektronischen Bauteilen. Es benötigt nur zwei Leitungen und damit nur 2 Digitalpins am Arduino:

• SDA (Serial Data Line) für die Datenübertragung
• SCL (Serial Clock Line) für den Takt

Jedes I²C-Gerät hat eine eindeutige Adresse. Dadurch können über dieselben zwei Pins mehrere Module wie Sensoren oder Displays angesprochen werden.

Für Standard-LCDs gibt es kleine I²C-Adapterplatinen, die einfach an die 16 Anschlusspins des Displays gelötet werden. Diese verwenden meist den PCF8574, einen I/O Expander, der serielle Daten in parallele Signale für das LCD umwandelt. Diese Adapter stellen dann die 4 I²C-Anschlüsse (VCC, GND, SDA, SCL) zur Verfügung. Ein Potentiometer zur Helligkeitssteuerung der Anzeige ist oft noch zusätzlich auf der Platine integriert.

Diese Erweiterungen sind praktisch, machen das Modul jedoch etwas unhandlicher. Aus diesem Grund gibt es inzwischen auch LCD Displays mit integrierter I²C-Schnittstelle, die direkt auf dem Modul verbaut ist und so den gewohnten Formfaktor beibehält.

Bestseller Nr. 1

FREENOVE I2C IIC LCD 1602 Module (2 Pack), New...

12,95 EUR

Bei Amazon kaufen

Bestseller Nr. 2

Freenove I2C IIC LCD 1602 Module, New Type TWI...

8,95 EUR

Bei Amazon kaufen

Bestseller Nr. 3

APKLVSR 2004 LCD Display Modul,4 Stück 20x...

Bei Amazon kaufen

Anschluss eines I²C-LCD Displays an den Arduino

Der Anschluss eines I²C-LCD Displays an den Arduino UNO ist denkbar einfach:

1. VCC an 5V
2. GND an GND
3. SDA an A4 (Arduino UNO)
4. SCL an A5 (Arduino UNO)

Hinweis: Bei anderen Mikrocontrollern können die I²C-Pins variieren.

• Arduino UNO/Nano: SDA an A4, SCL an A5.
• Arduino Micro: SDA an D2, SCL an D3.
• Arduino Mega 2560: SDA an D20, SCL an D21.
• ESP8266 (NodeMCU): SDA an GPIO4 (D2), SCL an GPIO5 (D1).
• ESP32: SDA an GPIO21, SCL an GPIO22.
• Raspberry Pi (Model 3 & 4): SDA an GPIO2 (Pin 3), SCL an GPIO3 (Pin 5).
• STM32 (Blue Pill): SDA an PB7, SCL an PB6.
• Teensy 4.x: SDA an Pin 18, SCL an Pin 19.

LCD Display, Zeichensatz und Sonderzeichen

LCD-Displays wie das 1602 oder 2004 verwenden oft einen HD44780-kompatiblen Controller, der einen festgelegten Zeichensatz (Character Generator ROM, CGROM) integriert hat. Dieser Zeichensatz basiert auf dem erweiterten ASCII-Code und enthält neben den englischen Buchstaben, Zahlen und Symbolen auch einige Sonderzeichen wie Pfeile oder mathematische Symbole. Allerdings fehlen häufig länderspezifische Sonderzeichen, etwa deutsche Umlaute (ä, ö, ü) oder das „ß“.

Für individuelle Anpassungen bietet der Controller einen benutzerdefinierten Zeichensatz (CGRAM), in dem bis zu acht eigene Zeichen definiert werden können. Diese Zeichen werden als 8×5-Pixel-Matrix erstellt und können zur Darstellung von Sonderzeichen oder Symbolen genutzt werden. Wenn jedoch mehr als acht Sonderzeichen benötigt werden, müssen diese dynamisch neu definiert werden, was bei häufiger Nutzung den Code komplexer macht.

Eine sehr gute Library zur Anzeige deutscher Umlaute samt umfangreicher Erklärung:
https://werner.rothschopf.net/202003_arduino_liquid_crystal_umlaute.htm

Einfacher Sekundenzähler auf einem LCD Display

#include <LCDI2C_Multilingual_MCD.h>

LCDI2C_Latin lcd(0x27, 16, 2); // I2C Adresse: 0x27; Display: 16x2

void setup() {
  lcd.init(); // Display initialisieren
  lcd.backlight(); // Hintergrundbeleuchtung einschalten
  lcd.setCursor(0, 0); // Cursor auf erstes Zeichen in erster Zeile
  lcd.print("Sekunden:"); // Text in erster Zeile ausgeben
}

void loop() {
    unsigned long seconds = millis() / 1000;
 
    lcd.setCursor(0, 1); // Cursor auf erstes Zeichen in zweiter Zeile
    lcd.print(seconds); // Zeit seit Start in Sekunden ausgeben
    lcd.print("s   "); // s für Sekunden und ein paar Leerzeichen zum Überschreiben alter Werte
    delay(500); // Leichte Verzögerung, damit nicht dauernd geschrieben wird
}

I²C-Adressen verstehen und ändern

Da alle über I²C angesteuerten Geräte über einen gemeinsamen Datenbus angesprochen werden, benötigt jedes Gerät eine eindeutige Adresse. Die Standardadresse für viele LCD-I²C-Module ist 0x27 (hexadezimal).

Wenn mehrere Displays verwendet werden sollen oder es einen Adresskonflikt mit anderen Geräten gibt, dann müssen unterschiedliche Adressen vergeben werden. Auf der Rückseite des I²C-Moduls befinden sich dazu drei Pins: A0, A1 und A2. Diese Pins steuern die letzten 3 Bits der I²C-Adresse.

• Offen (HIGH): Das Bit ist auf 1 gesetzt.
• Kurzgeschlossen (LOW): Das Bit wird auf 0 gesetzt.

Beispiel (I²C Adressen in 7 Bit)

• A0 geschlossen: Ändert die Adresse von 0x27 (0b0100111) auf 0x26 (0b0100110).
• A1 geschlossen: Ändert die Adresse von 0x27 (0b0100111) auf 0x25 (0b0100101).
• Alle geschlossen: Adresse ändert sich von 0x27 (0b0100111) auf 0x20 (0b0100000).

So lassen sich mehrere Displays mit unterschiedlichen Adressen am selben I²C-Bus betreiben.

Drei Displays gleichzeitig ansteuern

In diesem Beispiel werden drei Displays über den I²C-Bus gleichzeitig angesteuert. Die Displays zeigen unterschiedliche Informationen an.

#include <LCDI2C_Multilingual_MCD.h>

LCDI2C_Latin lcd1(0x25, 16, 2); // I2C Adresse: 0x25; Display: 16x2
LCDI2C_Latin lcd2(0x26, 16, 2); // I2C Adresse: 0x26; Display: 16x2
LCDI2C_Latin lcd3(0x27, 20, 4); // I2C Adresse: 0x27; Display: 20x4

unsigned long lastSecond = 0; // Zwischenspeicher für Fortschrittsbalken
int progressBar = 0; // Aktuelle Länge des Fortschrittbalkens

void setup() {
  lcd1.init(); // Display1 initialisieren
  lcd1.backlight(); // Hintergrundbeleuchtung einschalten
  lcd1.setCursor(0, 0); // Cursor auf erstes Zeichen in erster Zeile
  lcd1.print("Sekunden:"); // Text in erster Zeile ausgeben

  lcd2.init(); // Display 2 initialisieren
  lcd2.backlight(); 
  lcd2.setCursor(0, 0); 
  lcd2.print("Millisekunden:"); 

  lcd3.init(); // Display 3 initialisieren
  lcd3.backlight(); 
  lcd3.setCursor(0, 0); 
  lcd3.print("Fortschrittsbalken:"); 
}

void loop() {

    unsigned long currentMillis = millis();
    unsigned long currentSeconds = currentMillis / 1000;

    // Display 1 - aktuelle Zeit in Sekunden
    lcd1.setCursor(0, 1); // Cursor auf erstes Zeichen in zweiter Zeile
    lcd1.print(currentSeconds); // Zeit seit Start in Sekunden ausgeben
    lcd1.print("s"); // sec für Sekunden

    // Display 2 - Zeit in Millisekunden
    lcd2.setCursor(0, 1);
    lcd2.print(currentMillis); // Zeit seit Start in Millisekunden ausgeben
    lcd2.print("ms");


    // Display 3: Fortschrittsbalken aktualisieren (60 Zeichen pro Minute)
    if (lastSecond != currentSeconds) { // Nur aktualisieren, wenn sich der Inhalt geändert hat
        progressBar = currentSeconds % 60; // Fortschritt von 0 bis 59
        lastSecond = currentSeconds;
        
        // Fortschrittsbalken leeren bei Neuanfang
        if (progressBar == 0) {
          for (int row = 1; row <= 3; row++) {
            lcd3.setCursor(0, row);
            lcd3.print("                    ");
          }
        }

        // Fortschrittsbalken zeichnen
        int row = 1;
        int col = 0;
        for (int i = 0; i < progressBar; i++) {
            lcd3.setCursor(col, row);
            lcd3.print("#");
            col++;
            if (col >= 20) { // Nächste Zeile nach 20 Zeichen
                col = 0;
                row++;
            }
        }
    }

}

Mit einer I²C-Schnittstelle kann man LCD Displays einfach ansteuern und in jedes Projekt integrieren. Anstatt für jedes Display mehrere Pins zu belegen, genügen zwei Pins (SDA und SCL), um mehrere Displays oder Sensoren zu betreiben. Das ermöglicht komplexe Projekte, ohne sich Gedanken über fehlende GPIO-Pins machen zu müssen.

Dank der verfügbaren Libraries und einfacher Adressänderungen ist die Einrichtung von I²C-LCDs schnell erledigt. Ob ein einzelnes Display oder mehrere Module gleichzeitig – mit I²C sind die Möglichkeiten nahezu unbegrenzt.

Bestseller Nr. 1

ELEGOO UNO R3 Ultimate Starter Kit, Kompatibel mit Arduino IDE Vollständigster Elektronik Projekt Baukasten mit deutschem Tutorial, UNO R3 Mikrocontroller Board und Zubehör (mehr als 200 Teile)

52,99 EUR