Arduino-games: zo bouw je Pong, T-Rex, Snake en Simon
Arduino-gameprojecten stap voor stap: Pong en T-Rex op een oled, Snake op een ledmatrix, Simon, een LCD-runner en een reactietest, plus code voor een EEPROM-highscore.
Games maken met Arduino is de leukste manier om elektronica en programmeren te leren: met een oled-display, een paar knoppen en een joystick bouw je zelf klassiekers als Pong, de T-Rex-runner, Snake en het geheugenspel Simon, en daag je vrienden uit om jouw highscore te verbreken. Terwijl je een game schrijft, leer je bijna vanzelf de belangrijkste programmeeronderwerpen: timing, toestandsmachines, coördinatenstelsels, botsingsberekeningen, willekeurige getallen en permanent geheugen. Al deze games draaien op één Arduino Uno; de 2 KB RAM is genoeg zolang je zuinig met geheugen omgaat.
In deze gids bouwen we zes games van begin tot eind: Pong en de T-Rex-runner op een oled-display, Snake op een NeoPixel-ledmatrix van 8x8 en 16x16, Simon met vier leds en vier knoppen, een runnergame op een LCD van 16x2 en een reactietest die op de milliseconde nauwkeurig is. Elke game komt met een onderdelenlijst, bedrading en code die compileert. We leren eerst het skelet dat ze allemaal delen, namelijk de gameloop, botsingsdetectie, scores en het opslaan van een highscore in EEPROM, en gebruiken dat daarna in elke game opnieuw. Aan het eind vind je ook versies voor ESP32 en Raspberry Pi Pico.

Welke game heeft welke onderdelen nodig?
Als je een game maakt met Arduino, is de eerste keuze het display, want het display bepaalt wat voor game je kunt maken. Met een paar leds bouw je al Simon of een reactietest, terwijl een oled van 128×64 pixels Pong en T-Rex mogelijk maakt, met bewegende graphics en natuurkunde. De tabel hieronder vat de games in deze gids samen, van makkelijk naar moeilijk:
| Game | Display | Invoer | Overige onderdelen | Niveau |
|---|---|---|---|---|
| Reactietest | 1 led + Serial Monitor | 1 knop | 220 Ω-weerstand, optioneel een buzzer | Makkelijk |
| Simon-geheugenspel | 4 gekleurde leds | 4 knoppen | 4 × 220 Ω-weerstanden, passieve buzzer | Makkelijk–gemiddeld |
| LCD-runner | 16x2 I2C LCD | 1 knop | Passieve buzzer | Gemiddeld |
| Pong | 0,96" SSD1306 oled | Joystick of 10 kΩ-potmeter | Passieve buzzer | Gemiddeld |
| T-Rex-runner | 0,96" SSD1306 oled | 1 knop of de joystickknop | Passieve buzzer | Gemiddeld |
| Snake (8x8) | 8x8 NeoPixel-matrix | Joystick | 330 Ω-weerstand, 1000 µF-condensator | Gemiddeld–gevorderd |
| Snake (16x16) | 16x16 NeoPixel-matrix | Joystick | Externe voeding van 5 V, 3–4 A | Gevorderd |






Gedeelde bedrading: één schakeling als gameconsole
We hebben gedeelde pins gekozen, zodat elke game behalve Simon op dezelfde schakeling draait. De oled en de I2C-LCD delen dezelfde twee draden (SDA en SCL); de joystick gaat naar de analoge ingangen, de actieknop naar D3 en de buzzer naar D8. Als je deze "gameconsole" eenmaal hebt gebouwd, wissel je van game door andere code te uploaden. De volledige pinindeling van je board zie je in de tool Pinout.
| Onderdeel / pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Oled of I2C-LCD: SDA | A4 | GPIO 21 | GP4 |
| Oled of I2C-LCD: SCL | A5 | GPIO 22 | GP5 |
| Joystick VRx (X-as) | A0 | GPIO 34 | GP26 |
| Joystick VRy (Y-as) | A1 | GPIO 35 | GP27 |
| Joystick SW (knop) | D2 | GPIO 25 | GP15 |
| Actieknop (andere pootje naar GND) | D3 | GPIO 26 | GP14 |
| Passieve buzzer (+) | D8 | GPIO 27 | GP16 |
| NeoPixel DIN (via 330 Ω) | D6 | GPIO 13 | GP22 |
Hoe werkt een gameloop?
Elke videogame is gebouwd op een lus van vier stappen die tientallen keren per seconde wordt herhaald: de invoer lezen (knoppen, joystick), de wereld bijwerken (positie, snelheid, score), botsingen controleren en het scherm tekenen. Eén ronde door de lus heet een frame. Dertig frames per seconde (30 FPS) is genoeg om er vloeiend uit te zien, wat betekent dat elk frame ongeveer 33 ms duurt. De functie loop() van Arduino is al een lus, maar hij draait heel snel en onregelmatig, dus moet je hem met millis() opdelen in vaste frames.
delay() vermijden is hier essentieel. Schrijf je delay(33), dan doet de Arduino die 33 ms niets, kan hij een korte knopdruk missen en verandert de gamesnelheid telkens als het tekenen meer of minder tijd kost. Met millis() leest loop() bij elke ronde de invoer, maar gaat de game pas verder als het tijd is voor een nieuw frame. Het verschil tussen die twee vind je uitgebreid uitgelegd in Arduino millis vs delay. Het onderstaande skelet is de basis van elke game in deze gids:
1// Oyun döngüsü iskeleti / Game loop skeleton
2enum State { MENU, PLAYING, GAME_OVER }; // oyunun durumları / game states
3State state = MENU;
4
5const byte BUTTON_PIN = 3; // aksiyon butonu / action button
6const unsigned long FRAME_MS = 33; // ~30 kare/sn / ~30 frames per second
7unsigned long lastFrame = 0;
8unsigned int score = 0;
9
10// Sıçramasız basış: yalnız basıldığı an true / bounce-free: true only at the moment of a press
11bool buttonPressed() {
12 static bool stable = HIGH, lastRead = HIGH;
13 static unsigned long changedAt = 0;
14 bool r = digitalRead(BUTTON_PIN);
15 if (r != lastRead) { lastRead = r; changedAt = millis(); }
16 if (millis() - changedAt > 15 && r != stable) { // 15 ms sabit kaldı mı? / stable for 15 ms?
17 stable = r;
18 return stable == LOW;
19 }
20 return false;
21}
22
23void setup() {
24 pinMode(BUTTON_PIN, INPUT_PULLUP); // basınca LOW / LOW when pressed
25 Serial.begin(9600);
26}
27
28void loop() {
29 bool pressed = buttonPressed(); // 1) giriş: her turda oku / input: read on every pass
30 if (pressed && state != PLAYING) { // menüden ya da oyun sonundan başlat / start from menu or game over
31 score = 0;
32 state = PLAYING;
33 }
34 if (millis() - lastFrame < FRAME_MS) return; // kare zamanı gelmedi / not time for a frame yet
35 lastFrame = millis();
36
37 if (state == PLAYING) {
38 score++; // 2) güncelle: konum, hız, puan / update: position, speed, score
39 if (score >= 300) state = GAME_OVER; // 3) çarpışma ya da bitiş kontrolü / collision or end check
40 Serial.println(score); // 4) çiz: burada ekrana çizilir / draw: the screen is drawn here
41 }
42}Het tweede kernidee in de code is de toestandsmachine. Op elk moment zit de game in een van drie toestanden: MENU, PLAYING of GAME_OVER. Elke toestand reageert anders op dezelfde knop: in het menu start een druk de game, tijdens het spel laat hij het personage springen, en na game over begint hij een nieuwe ronde. Door de code zo te splitsen verdwijnen geneste if-blokken en is het makkelijk een nieuwe toestand toe te voegen, zoals PAUSE. Dit onderwerp behandelen we dieper in Arduino-toestandsmachine.
Knoppen en een joystick uitlezen
Knoppen aansluiten met INPUT_PULLUP is de properste methode: je hebt geen externe weerstand nodig, de pin leest HIGH in rust en LOW als je indrukt. Een mechanische knop dendert echter een paar milliseconden bij het indrukken of loslaten, en de Arduino ziet dat als meerdere drukken achter elkaar. In een game betekent dat twee keer springen bij één druk, of Simon die een verkeerde kleur telt. De functie buttonPressed() in het skelet accepteert pas een nieuwe toestand als de pin 15 ms hetzelfde is gebleven, en geeft slechts één keer true terug, op het moment van indrukken. Voor de schakeling en andere methodes kun je kijken bij Een knop aansluiten op Arduino.
Een joystick bestaat uit twee potmeters en een knop. Op de Uno geeft elke as een waarde van 0 tot 1023, en met losgelaten stick ligt het midden rond 512, maar dat verschilt per module tussen ongeveer 490 en 530. Daarom gebruiken rastergames drempels in plaats van exacte waarden: onder 300 betekent links of omhoog, boven 700 rechts of omlaag. De brede zone ertussen (de dode zone) voorkomt dat het personage vanzelf wegdrijft als je loslaat. In Pong koppelen we de analoge waarde juist rechtstreeks aan de paddle: map() zet het bereik 0–1023 om naar de slag van 0–48 pixels van de paddle. Kalibratie en de richtingentabel staan in de gids over de joystickmodule.
Hoe werkt botsingsdetectie?
Botsingsdetectie vraagt of twee objecten tegelijk op dezelfde plek zijn. Bij games met een scherm is de gangbaarste methode de AABB-test (axis-aligned bounding box): je behandelt elk object als een rechthoek. Twee rechthoeken overlappen alleen als alle vier de voorwaarden tegelijk waar zijn: de linkerrand van A ligt links van de rechterrand van B, de rechterrand van A ligt rechts van de linkerrand van B, en dezelfde twee voorwaarden gelden op de verticale as. In code is het één regel: ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by. Bij rastergames (Snake, de LCD-runner) is het nog simpeler: hebben twee cellen dezelfde coördinaten, dan is er een botsing.
| Game | Wat botst met wat? | Methode |
|---|---|---|
| Pong | Bal met de muren en paddles | AABB + de snelheid omkeren |
| T-Rex | Dinosaurus met de cactussen | AABB (met een iets kleinere box) |
| Snake | Kop met de muren, het lichaam en het voer | Gelijkheid van rastercellen |
| LCD-runner | Runner met een cactus | Zelfde kolom en zelfde rij |
| Simon | Ingedrukte kleur met de kleur in de reeks | Vergelijking van arrayelementen |
| Reactietest | Drukmoment met signaalmoment | Tijdsvergelijking (valse start) |
Scores bijhouden en een highscore opslaan in EEPROM
De score staat in een variabele in RAM en verdwijnt zodra je de Arduino loskoppelt. Om een highscore permanent te maken gebruik je EEPROM: de ATmega328P van de Arduino Uno heeft 1024 bytes EEPROM die zijn inhoud zonder stroom behoudt. Twee bytes van het type uint16_t zijn genoeg voor een highscore (0–65535). Het enige zwakke punt van EEPROM is de schrijfduurzaamheid: elke cel kan ongeveer 100.000 keer worden beschreven. Dat klinkt veel, maar schrijf je de score elk frame, 30 keer per seconde, dan is de cel na ongeveer 55 minuten versleten. De juiste aanpak is alleen schrijven als de game eindigt en het record is verbroken; zelfs met 10 nieuwe records per dag gaat de cel 27 jaar mee.
1#include <EEPROM.h>
2
3const int HISCORE_ADDR = 0; // rekor EEPROM'un 0-1. baytında / high score in EEPROM bytes 0-1
4uint16_t hiScore = 0;
5
6uint16_t loadHiScore() {
7 uint16_t v;
8 EEPROM.get(HISCORE_ADDR, v); // 2 bayt oku / read 2 bytes
9 if (v == 0xFFFF) v = 0; // hiç yazılmamış EEPROM 0xFF okunur / blank EEPROM reads 0xFF
10 return v;
11}
12
13void saveIfRecord(uint16_t score) {
14 if (score > hiScore) { // yalnız rekor kırılınca yaz / write only on a new record
15 hiScore = score;
16 EEPROM.put(HISCORE_ADDR, hiScore); // put() yalnız değişen baytları yazar / put() writes only changed bytes
17 }
18}
19
20void setup() {
21 Serial.begin(9600);
22 hiScore = loadHiScore();
23 Serial.print(F("Rekor / High score: "));
24 Serial.println(hiScore);
25 saveIfRecord(120); // örnek: oyun 120 puanla bitti / example: a game ended with 120 points
26}
27
28void loop() {}De code heeft twee subtiele punten. Ten eerste is elke byte van een EEPROM die nooit is beschreven 0xFF, dus bij de allereerste start verschijnt de highscore als 65535, en de controle op 0xFFFF maakt er 0 van. Bij de reactietest is het andersom: 0xFFFF betekent "nog geen record", omdat een kortere tijd daar beter is. Ten tweede leest EEPROM.put() elke byte voordat hij schrijft en schrijft alleen de bytes die zijn veranderd, wat de levensduur nog verder verlengt. Voor de andere EEPROM-commando's, zie De Arduino-EEPROM gebruiken. Zodat je de games in deze gids na elkaar op dezelfde Uno kunt laden, heeft elke game een eigen adres:
| Game | EEPROM-adres | Opgeslagen waarde |
|---|---|---|
| T-Rex-runner | 0–1 | Hoogste score |
| Snake | 2–3 | Meeste voer gegeten |
| LCD-runner | 4–5 | Hoogste score |
| Reactietest | 6–7 | Kortste tijd (ms) |
| Simon | 8–9 | Hoogste bereikte level |
Pong: oled-display en joystick
Pong is het tafeltennisspel uit 1972 dat het tijdperk van de videogames op gang bracht. In onze versie bestuur je de linker paddle met de Y-as van de joystick (of een potmeter op A1) en speelt de Arduino de rechter paddle. Onderdelen: een Arduino Uno, een 0,96-inch SSD1306 I2C-oled, een joystick en een passieve buzzer. Installeer je de bibliotheek Adafruit SSD1306 via de Library Manager, installeer dan ook de afhankelijkheid Adafruit GFX. De bedrading van het display en de tekencommando's worden uitgebreid uitgelegd in Oled-display SSD1306.
1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4
5Adafruit_SSD1306 display(128, 64, &Wire, -1);
6
7const byte JOY_Y_PIN = A1; // joystick VRy ya da potansiyometre / joystick VRy or potentiometer
8const byte BUZZER_PIN = 8; // pasif buzzer / passive buzzer
9const byte PADDLE_H = 16, PADDLE_W = 3;
10const byte WIN_SCORE = 5; // 5 sayı alan kazanır / first to 5 wins
11const float MAX_SPEED = 2.8; // raketten kalın olmasın / keep below paddle thickness + ball size
12const unsigned long FRAME_MS = 30; // ~33 kare/sn / ~33 frames per second
13
14float ballX, ballY, velX, velY;
15float playerY = 24, cpuY = 24;
16byte playerScore = 0, cpuScore = 0;
17unsigned long lastFrame = 0;
18
19void serve(int dir) { // topu ortadan at / serve from the center
20 ballX = 63; ballY = 31;
21 velX = 1.8 * dir;
22 velY = random(-10, 11) / 10.0; // -1,0 ile 1,0 arası / between -1.0 and 1.0
23}
24
25// Topun rakete çarptığı nokta yeni açıyı belirler / where the ball hits the paddle sets the new angle
26void hitPaddle(float paddleY) {
27 float offset = (ballY + 1 - (paddleY + PADDLE_H / 2.0)) / (PADDLE_H / 2.0); // -1 üst, +1 alt / -1 top, +1 bottom
28 velX = constrain(-velX * 1.05, -MAX_SPEED, MAX_SPEED); // yön değiştir, %5 hızlan / reverse, 5% faster
29 velY = offset * 1.5;
30 tone(BUZZER_PIN, 880, 15);
31}
32
33void setup() {
34 Serial.begin(9600);
35 if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
36 Serial.println(F("SSD1306 allocation failed"));
37 for (;;); // ekran yoksa dur / halt without a display
38 }
39 display.setTextColor(SSD1306_WHITE);
40 randomSeed(analogRead(A3)); // boştaki analog pin / a floating analog pin
41 serve(1);
42}
43
44void loop() {
45 if (millis() - lastFrame < FRAME_MS) return;
46 lastFrame = millis();
47
48 // 1) Giriş: oyuncu raketi / Input: player paddle
49 playerY = map(analogRead(JOY_Y_PIN), 0, 1023, 0, 64 - PADDLE_H);
50
51 // 2) Basit yapay zekâ: CPU topu sınırlı hızla izler / Simple AI: the CPU follows the ball at limited speed
52 float target = ballY - PADDLE_H / 2.0;
53 cpuY += constrain(target - cpuY, -1.2, 1.2);
54 cpuY = constrain(cpuY, 0, 64 - PADDLE_H);
55
56 // 3) Topu hareket ettir / Move the ball
57 ballX += velX;
58 ballY += velY;
59
60 // 4) Çarpışmalar / Collisions
61 if (ballY <= 0 || ballY >= 62) { // üst ve alt duvar / top and bottom walls
62 velY = -velY;
63 ballY = constrain(ballY, 0, 62);
64 }
65 if (velX < 0 && ballX <= 4 && ballX > 0 && ballY + 2 >= playerY && ballY <= playerY + PADDLE_H) {
66 ballX = 4;
67 hitPaddle(playerY);
68 }
69 if (velX > 0 && ballX >= 122 && ballX < 126 && ballY + 2 >= cpuY && ballY <= cpuY + PADDLE_H) {
70 ballX = 122;
71 hitPaddle(cpuY);
72 }
73
74 // 5) Sayı / Point
75 if (ballX <= 0) { cpuScore++; tone(BUZZER_PIN, 220, 200); serve(1); }
76 if (ballX >= 126) { playerScore++; tone(BUZZER_PIN, 660, 200); serve(-1); }
77
78 // 6) Çiz / Draw
79 display.clearDisplay();
80 for (byte y = 0; y < 64; y += 6) display.drawFastVLine(63, y, 3, SSD1306_WHITE); // orta çizgi / center line
81 display.fillRect(1, (int)playerY, PADDLE_W, PADDLE_H, SSD1306_WHITE);
82 display.fillRect(124, (int)cpuY, PADDLE_W, PADDLE_H, SSD1306_WHITE);
83 display.fillRect((int)ballX, (int)ballY, 2, 2, SSD1306_WHITE);
84 display.setTextSize(1);
85 display.setCursor(52, 0); display.print(playerScore);
86 display.setCursor(70, 0); display.print(cpuScore);
87 display.display();
88
89 // 7) Oyun bitti mi? / Game over?
90 if (playerScore >= WIN_SCORE || cpuScore >= WIN_SCORE) {
91 display.setTextSize(2);
92 if (playerScore >= WIN_SCORE) { display.setCursor(22, 24); display.print(F("YOU WIN")); }
93 else { display.setCursor(10, 24); display.print(F("GAME OVER")); }
94 display.display();
95 delay(3000);
96 playerScore = cpuScore = 0;
97 serve(1);
98 }
99}Wat Pong leuk maakt, is de functie hitPaddle(). Raakt de bal het midden van de paddle, dan komt hij bijna recht terug; raakt hij de rand, dan kaatst hij onder een scherpe hoek weg en zet hij de tegenstander onder druk. Dat doen we door de afstand van de bal tot het midden van de paddle te schalen naar een waarde tussen -1 en +1 en die om te zetten in verticale snelheid. De bal wordt bij elke treffer 5% sneller en wordt begrensd door MAX_SPEED. De paddle van de Arduino kan hooguit 1,2 pixel per frame bewegen, dus geef je de bal een scherpe hoek, dan kan hij hem niet bijhouden en scoor jij. Wil je de game moeilijker maken, verhoog die waarde dan naar 1.5; voor twee spelers verwijder je de CPU-regels en bestuur je de tweede paddle met een potmeter op A2.
Waarom een frametijd van 30 ms? De Uno stuurt de framebuffer van 1024 bytes in ongeveer 25 ms via 400 kHz I2C naar de oled, dus het display kan niet meer dan 35–40 frames per seconde tonen. Door de frametijd net boven die overdrachtstijd te houden, blijft de gamesnelheid constant. En laat je niet misleiden door de melding "Global variables use 28%" van de compiler: de SSD1306-buffer wordt tijdens het uitvoeren gereserveerd, dus het echte RAM-gebruik loopt op tot ongeveer 78%. Raakt het geheugen op, dan zie je de fout SSD1306 allocation failed; de oplossingen hebben we verzameld in Arduino-geheugen te klein.
T-Rex-runner: sprongfysica en highscore
We brengen het dinosaurusspel dat Chrome toont als je offline bent naar het oled-display. De dinosaurus rent op de plek, cactussen schuiven van rechts naar links en jij springt eroverheen door op de knop te drukken. Om de sprong realistisch te laten lijken gebruiken we simpele natuurkunde: een druk op de knop zet de verticale snelheid op -4.2 pixels per frame, elk frame telt de zwaartekracht 0.3 op bij die snelheid en de positie verandert met de snelheid. Zo stijgt de dinosaurus terwijl hij vertraagt, hangt hij even bovenin en valt hij steeds sneller; hij klimt ongeveer 27 pixels en blijft 27 frames in de lucht, ongeveer 0,8 seconde. De onderdelen zijn dezelfde als bij Pong; om te springen gebruik je de knop op D3 of de joystickknop.
1#include <Wire.h>
2#include <EEPROM.h>
3#include <Adafruit_GFX.h>
4#include <Adafruit_SSD1306.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1);
7
8const byte JUMP_PIN = 3; // aksiyon butonu / action button
9const byte JOY_SW_PIN = 2; // joystick butonu da zıplatır / the joystick button jumps too
10const byte BUZZER_PIN = 8;
11const int HISCORE_ADDR = 0; // EEPROM 0-1. bayt / EEPROM bytes 0-1
12const byte GROUND_Y = 56; // zemin çizgisi / ground line
13const byte DINO_X = 10, DINO_W = 14, DINO_H = 14;
14const float JUMP_V = -4.2; // zıplama hızı (piksel/kare) / jump speed (px/frame)
15const float GRAVITY = 0.3; // yer çekimi (piksel/kare²) / gravity (px/frame²)
16const unsigned long FRAME_MS = 30; // ~33 kare/sn / ~33 frames per second
17
18enum State { MENU, PLAYING, GAME_OVER };
19State state = MENU;
20
21struct Cactus { float x; byte w, h; };
22Cactus cacti[2];
23
24float dinoY, velY, speed;
25uint16_t score = 0, hiScore = 0;
26unsigned long lastFrame = 0;
27
28bool jumpHeld() {
29 return digitalRead(JUMP_PIN) == LOW || digitalRead(JOY_SW_PIN) == LOW;
30}
31
32uint16_t loadHiScore() {
33 uint16_t v;
34 EEPROM.get(HISCORE_ADDR, v);
35 return (v == 0xFFFF) ? 0 : v; // boş EEPROM 0xFFFF okunur / blank EEPROM reads 0xFFFF
36}
37
38void placeCactus(byte i, float startX) {
39 cacti[i].x = startX;
40 cacti[i].w = random(4, 9); // 4-8 piksel genişlik / 4-8 px wide
41 cacti[i].h = random(8, 17); // 8-16 piksel yükseklik / 8-16 px tall
42}
43
44void resetGame() {
45 dinoY = GROUND_Y - DINO_H;
46 velY = 0;
47 speed = 2.0;
48 score = 0;
49 placeCactus(0, 140);
50 placeCactus(1, 140 + random(70, 140));
51}
52
53// İki dikdörtgen üst üste biniyor mu? (AABB) / Do two rectangles overlap? (AABB)
54bool overlap(int ax, int ay, int aw, int ah, int bx, int by, int bw, int bh) {
55 return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
56}
57
58void drawDino(int x, int y, bool legA) {
59 display.fillRect(x + 6, y, 8, 5, SSD1306_WHITE); // kafa / head
60 display.drawPixel(x + 9, y + 1, SSD1306_BLACK); // göz / eye
61 display.fillRect(x, y + 5, 10, 6, SSD1306_WHITE); // gövde / body
62 display.fillRect(x + 2, y + 11, 2, legA ? 3 : 1, SSD1306_WHITE); // sol bacak / left leg
63 display.fillRect(x + 6, y + 11, 2, legA ? 1 : 3, SSD1306_WHITE); // sağ bacak / right leg
64}
65
66void drawScene() {
67 display.clearDisplay();
68 display.drawFastHLine(0, GROUND_Y, 128, SSD1306_WHITE);
69 bool onGround = dinoY >= GROUND_Y - DINO_H;
70 drawDino(DINO_X, (int)dinoY, onGround ? (score / 4) % 2 : true); // koşma animasyonu / running animation
71 for (byte i = 0; i < 2; i++) {
72 display.fillRect((int)cacti[i].x, GROUND_Y - cacti[i].h, cacti[i].w, cacti[i].h, SSD1306_WHITE);
73 }
74 display.setTextSize(1);
75 display.setCursor(0, 0); display.print(score);
76 display.setCursor(80, 0); display.print(F("HI ")); display.print(hiScore);
77}
78
79void showMessage(const __FlashStringHelper *msg) {
80 display.fillRect(14, 18, 100, 28, SSD1306_BLACK);
81 display.drawRect(14, 18, 100, 28, SSD1306_WHITE);
82 display.setCursor(64 - strlen_P((const char *)msg) * 3, 28); // ortala (karakter 6 piksel) / center (6 px per char)
83 display.print(msg);
84 display.display();
85}
86
87void gameOver() {
88 tone(BUZZER_PIN, 150, 300);
89 if (score > hiScore) { // yeni rekor: yalnız şimdi yaz / new record: write only now
90 hiScore = score;
91 EEPROM.put(HISCORE_ADDR, hiScore);
92 }
93 drawScene();
94 showMessage(F("GAME OVER"));
95 delay(800); // basılı buton hemen yeniden başlatmasın / a held button must not restart at once
96 state = GAME_OVER;
97}
98
99void setup() {
100 pinMode(JUMP_PIN, INPUT_PULLUP);
101 pinMode(JOY_SW_PIN, INPUT_PULLUP);
102 Serial.begin(9600);
103 if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
104 Serial.println(F("SSD1306 allocation failed"));
105 for (;;);
106 }
107 display.setTextColor(SSD1306_WHITE);
108 randomSeed(analogRead(A3));
109 hiScore = loadHiScore();
110 if (digitalRead(JUMP_PIN) == LOW) { // açılışta basılıysa rekoru sıfırla / held at power-up: reset the record
111 hiScore = 0;
112 EEPROM.put(HISCORE_ADDR, hiScore);
113 }
114 resetGame();
115 drawScene();
116 showMessage(F("PRESS START"));
117}
118
119void loop() {
120 if (millis() - lastFrame < FRAME_MS) return;
121 lastFrame = millis();
122
123 if (state != PLAYING) { // menü ya da oyun sonu: basınca başla / menu or game over: press to start
124 if (jumpHeld()) {
125 while (jumpHeld()); // bırakılmasını bekle / wait for release
126 resetGame();
127 state = PLAYING;
128 }
129 return;
130 }
131
132 // 1) Giriş ve fizik / Input and physics
133 bool onGround = dinoY >= GROUND_Y - DINO_H;
134 if (onGround && jumpHeld()) {
135 velY = JUMP_V;
136 tone(BUZZER_PIN, 1200, 20);
137 }
138 velY += GRAVITY; // her karede hız artar / velocity grows every frame
139 dinoY += velY;
140 if (dinoY > GROUND_Y - DINO_H) { dinoY = GROUND_Y - DINO_H; velY = 0; } // yere indi / landed
141
142 // 2) Engeller ve çarpışma / Obstacles and collision
143 for (byte i = 0; i < 2; i++) {
144 cacti[i].x -= speed;
145 if (cacti[i].x < -(float)cacti[i].w) { // ekrandan çıktı / left the screen
146 float otherX = cacti[1 - i].x;
147 placeCactus(i, max(128.0, otherX + random(70, 140)));
148 }
149 // biraz küçük çarpışma kutusu daha adil hissettirir / a slightly smaller hitbox feels fairer
150 if (overlap(DINO_X + 2, (int)dinoY + 1, DINO_W - 4, DINO_H - 2,
151 (int)cacti[i].x, GROUND_Y - cacti[i].h, cacti[i].w, cacti[i].h)) {
152 gameOver();
153 return;
154 }
155 }
156
157 // 3) Puan ve zorluk / Score and difficulty
158 score++;
159 if (score % 200 == 0 && speed < 5.0) speed += 0.25; // yaklaşık 6 sn'de bir hızlan / speed up every ~6 s
160
161 // 4) Çiz / Draw
162 drawScene();
163 display.display();
164}| Instelling | Waarde | Effect |
|---|---|---|
| JUMP_V | -4.2 | Sprongkracht; bij -5 klimt de dinosaurus ongeveer 40 pixels, dicht bij de bovenkant van het scherm |
| GRAVITY | 0.3 | Een grotere waarde maakt de sprong korter en scherper |
| speed | 2.0 → 5.0 | Snelheid van de cactussen; groeit elke 200 frames met 0.25 |
| random(70, 140) | pixels | Afstand tussen twee cactussen; kleinere waarden maken de game moeilijker |
| Hitbox | 10×12 pixels | Kleiner dan de getekende dinosaurus van 14×14, zodat net gemiste botsingen niet als dood tellen |
De highscore wordt naar EEPROM geschreven op het moment dat de game eindigt, en alleen als hij is verbroken; hij verschijnt rechtsboven als HI. Houd je de D3-knop ingedrukt terwijl je het board van stroom voorziet, dan wordt het record gereset, handig als je met vrienden een nieuw toernooi start. De hoogte en breedte van de cactussen komen uit random(). Zodat elke game anders begint, gebruikt de regel randomSeed(analogRead(A3)) de ruis van een niet-aangesloten analoge pin als seed.
Snake op een ledmatrix (8x8 en 16x16)
Het Snake-spel dat beroemd werd op oude Nokia-telefoons speel je het best op een ledmatrix, omdat elke led één spelcel is. We gebruiken een WS2812B NeoPixel-kleurenmatrix: de 8x8-versie heeft 64 pixels en de 16x16-versie 256, allemaal aangestuurd via één datadraad. Het lichaam van de slang wordt opgeslagen in twee arrays (snakeX en snakeY), waarbij element 0 de kop is. Bij elke stap schuift het lichaam één cel op en wordt de nieuwe positie in de kop geschreven; als de slang eet, wordt de staart niet verwijderd, zodat hij één cel groeit. Installeer de bibliotheek Adafruit NeoPixel om de code te compileren; details over de bedrading staan in de gids WS2812B NeoPixel.
1#include <Adafruit_NeoPixel.h>
2#include <EEPROM.h>
3
4const byte W = 8, H = 8; // 16x16 matris için 16 yap / set to 16 for a 16x16 matrix
5const bool SERPENTINE = false; // zikzak dizilimli panelde true / true for zigzag-wired panels
6const byte DATA_PIN = 6; // DIN, 330 Ω üzerinden / DIN through 330 Ω
7const byte JOY_X = A0, JOY_Y = A1, JOY_SW = 2;
8const byte BUZZER_PIN = 8;
9const int HISCORE_ADDR = 2; // EEPROM 2-3. bayt / EEPROM bytes 2-3
10
11Adafruit_NeoPixel matrix(W * H, DATA_PIN, NEO_GRB + NEO_KHZ800);
12
13byte snakeX[W * H], snakeY[W * H]; // [0] baş, sonrası gövde / [0] head, then the body
14int snakeLen;
15int8_t dirX, dirY, nextDX, nextDY;
16byte foodX, foodY;
17unsigned int stepMs;
18unsigned long lastStep = 0;
19uint16_t hiScore;
20bool alive = false;
21
22// (x, y) → LED sırası / (x, y) → LED index
23uint16_t xyToIndex(byte x, byte y) {
24 if (SERPENTINE && (y & 1)) return y * W + (W - 1 - x); // tek satırlar ters yönde / odd rows run backwards
25 return y * W + x;
26}
27
28bool onSnake(byte x, byte y) {
29 for (int i = 0; i < snakeLen; i++) {
30 if (snakeX[i] == x && snakeY[i] == y) return true;
31 }
32 return false;
33}
34
35void placeFood() {
36 do { // yem yılanın üstüne düşmesin / food must not land on the snake
37 foodX = random(W);
38 foodY = random(H);
39 } while (onSnake(foodX, foodY));
40}
41
42void resetGame() {
43 snakeLen = 3;
44 for (int i = 0; i < snakeLen; i++) { snakeX[i] = 3 - i; snakeY[i] = H / 2; }
45 dirX = nextDX = 1; // sağa doğru başla / start moving right
46 dirY = nextDY = 0;
47 stepMs = 300;
48 placeFood();
49 alive = true;
50}
51
52void readJoystick() {
53 int x = analogRead(JOY_X), y = analogRead(JOY_Y);
54 // Geri dönüş yasak: kontrol şimdiki yöne göre / no reversing: check against the current direction
55 if (x < 300 && dirX != 1) { nextDX = -1; nextDY = 0; }
56 else if (x > 700 && dirX != -1) { nextDX = 1; nextDY = 0; }
57 else if (y < 300 && dirY != 1) { nextDX = 0; nextDY = -1; }
58 else if (y > 700 && dirY != -1) { nextDX = 0; nextDY = 1; }
59}
60
61void draw() {
62 matrix.clear();
63 matrix.setPixelColor(xyToIndex(foodX, foodY), matrix.Color(255, 0, 0)); // yem kırmızı / food red
64 for (int i = snakeLen - 1; i >= 0; i--) {
65 uint32_t c = (i == 0) ? matrix.Color(255, 200, 0) : matrix.Color(0, 160, 0); // baş sarı / head yellow
66 matrix.setPixelColor(xyToIndex(snakeX[i], snakeY[i]), c);
67 }
68 matrix.show();
69}
70
71void gameOver() {
72 alive = false;
73 uint16_t score = snakeLen - 3; // yenen yem sayısı / food eaten
74 tone(BUZZER_PIN, 150, 400);
75 if (score > hiScore) { hiScore = score; EEPROM.put(HISCORE_ADDR, hiScore); }
76 for (byte k = 0; k < 3; k++) { // kırmızı yanıp sön / flash red
77 matrix.fill(matrix.Color(80, 0, 0)); matrix.show(); delay(200);
78 matrix.clear(); matrix.show(); delay(200);
79 }
80 for (uint16_t i = 0; i < score && i < W * H; i++) matrix.setPixelColor(i, matrix.Color(0, 0, 120)); // puan kadar LED / one LED per point
81 matrix.show();
82 Serial.print(F("Skor / Score: ")); Serial.print(score);
83 Serial.print(F(" Rekor / Best: ")); Serial.println(hiScore);
84}
85
86void step() {
87 dirX = nextDX; dirY = nextDY;
88 int nx = snakeX[0] + dirX, ny = snakeY[0] + dirY;
89 if (nx < 0 || nx >= W || ny < 0 || ny >= H) { gameOver(); return; } // duvar / wall
90
91 bool eat = (nx == foodX && ny == foodY);
92 // Yem yoksa kuyruk ucu boşalacağı için ona çarpmak sayılmaz / without food the tail tip moves away, so it is not a hit
93 int checkLen = eat ? snakeLen : snakeLen - 1;
94 for (int i = 0; i < checkLen; i++) {
95 if (snakeX[i] == nx && snakeY[i] == ny) { gameOver(); return; } // kendine çarptı / hit itself
96 }
97
98 if (eat) snakeLen++;
99 for (int i = snakeLen - 1; i > 0; i--) { // gövdeyi bir hücre kaydır / shift the body one cell
100 snakeX[i] = snakeX[i - 1];
101 snakeY[i] = snakeY[i - 1];
102 }
103 snakeX[0] = nx; snakeY[0] = ny;
104
105 if (eat) {
106 tone(BUZZER_PIN, 1000, 40);
107 if (stepMs > 120) stepMs -= 10; // her yemde hızlan / faster after every food
108 if (snakeLen == W * H) { gameOver(); return; } // tahta doldu: kazandın / board full: you win
109 placeFood();
110 }
111}
112
113void setup() {
114 pinMode(JOY_SW, INPUT_PULLUP);
115 Serial.begin(9600);
116 matrix.begin();
117 matrix.setBrightness(30); // düşük parlaklık = düşük akım / low brightness = low current
118 randomSeed(analogRead(A3));
119 EEPROM.get(HISCORE_ADDR, hiScore);
120 if (hiScore == 0xFFFF) hiScore = 0;
121 resetGame();
122 draw();
123}
124
125void loop() {
126 if (!alive) { // oyun bitti: joystick butonuyla yeniden / game over: restart with the joystick button
127 if (digitalRead(JOY_SW) == LOW) { resetGame(); draw(); delay(300); }
128 return;
129 }
130 readJoystick(); // her turda oku, hiçbir hareketi kaçırma / read on every pass, never miss a move
131 if (millis() - lastStep >= stepMs) {
132 lastStep = millis();
133 step();
134 if (alive) draw();
135 }
136}In de code staan drie kritieke regels. Niet omkeren: als een slang die naar rechts beweegt ineens naar links draait, loopt hij tegen zijn eigen nek; readJoystick() controleert de nieuwe richting tegen de huidige richting van de slang in plaats van de wachtende, zodat zelfs twee snelle bewegingen hem niet kunnen omdraaien. Staartuitzondering: bij een stap zonder voer beweegt de punt van de staart weg, dus de kop naar die cel bewegen is geen botsing. Voer plaatsen: placeFood() blijft proberen tot het voer niet op de slang landt. Elk stukje voer verkort de staptijd met 10 ms (van 300 ms naar 120 ms); als de game eindigt, licht voor elk opgegeten stukje één led blauw op en gaat het record naar EEPROM.
Ook de manier waarop de leds in je matrix zijn doorverbonden is belangrijk. Op de meeste starre 8x8-boards lopen de leds rij voor rij in dezelfde richting (SERPENTINE = false). Flexibele 16x16-panelen zijn meestal in zigzag bedraad: de ene rij loopt van links naar rechts, de volgende van rechts naar links. Springt de slang diagonaal of loopt hij op elke tweede rij achteruit, zet dan SERPENTINE op true; komen de richtingen omgekeerd uit, draai dan de joystick of verwissel de drempels 300 en 700. Voor 16x16 zet je W en H gewoon op 16; de slangarrays nemen dan 512 bytes in, de NeoPixel-buffer 768 bytes en ongeveer 75% van het RAM van de Uno wordt gebruikt.

Simon-geheugenspel: 4 leds en 4 knoppen
Simon is het legendarische geheugenspel uit 1978: elke ronde voegt het apparaat één kleur toe aan de reeks en jij herhaalt de hele reeks in dezelfde volgorde. Onderdelen: vier gekleurde leds (groen, rood, geel, blauw), een weerstand van 220 Ω voor elke led, vier knoppen en een passieve buzzer. Sluit de leds aan op D9–D12, de knoppen op D2–D5 en de buzzer op D8; deze game is een aparte schakeling los van de gedeelde console. De juiste weerstand voor je leds kies je met de ledweerstandcalculator. De vier geluiden van de originele Simon zijn tonen van een A-majeurakkoord; de code gebruikt dezelfde tonen (330, 440, 554 en 659 Hz), dus het klinkt prettig, ook als je snel drukt.
1#include <EEPROM.h>
2
3const byte LED_PINS[4] = {9, 10, 11, 12}; // yeşil, kırmızı, sarı, mavi / green, red, yellow, blue
4const byte BUTTON_PINS[4] = {2, 3, 4, 5}; // LED'lerle aynı sırada / same order as the LEDs
5const int TONES[4] = {330, 440, 554, 659}; // E4, A4, C#5, E5: A majör akoru / A major chord
6const byte BUZZER_PIN = 8;
7const int HISCORE_ADDR = 8; // EEPROM 8-9. bayt / EEPROM bytes 8-9
8const byte MAX_LEVEL = 50;
9
10byte sequence[MAX_LEVEL];
11byte level = 0;
12uint16_t hiScore;
13
14void playColor(byte c, int ms) {
15 digitalWrite(LED_PINS[c], HIGH);
16 tone(BUZZER_PIN, TONES[c]);
17 delay(ms);
18 digitalWrite(LED_PINS[c], LOW);
19 noTone(BUZZER_PIN);
20}
21
22// Basılan rengi döndürür; 3 sn içinde basılmazsa -1 / returns the pressed colour; -1 after 3 s
23int waitForButton() {
24 unsigned long start = millis();
25 while (millis() - start < 3000) {
26 for (byte i = 0; i < 4; i++) {
27 if (digitalRead(BUTTON_PINS[i]) == LOW) {
28 playColor(i, 200); // basılan rengi göster / show the pressed colour
29 while (digitalRead(BUTTON_PINS[i]) == LOW); // bırakılmasını bekle / wait for release
30 delay(30); // sıçramayı atla / skip the bounce
31 return i;
32 }
33 }
34 }
35 return -1;
36}
37
38// LED'ler döner; ilk basış oyunu başlatır ve rastgeleliği tohumlar
39// LEDs chase until the first press, which starts the game and seeds the randomness
40void waitForStart() {
41 byte i = 0;
42 while (true) {
43 digitalWrite(LED_PINS[i], HIGH);
44 for (byte t = 0; t < 20; t++) { // 200 ms boyunca butonlara bak / poll the buttons for 200 ms
45 for (byte b = 0; b < 4; b++) {
46 if (digitalRead(BUTTON_PINS[b]) == LOW) {
47 digitalWrite(LED_PINS[i], LOW);
48 randomSeed(micros()); // basış anı her seferinde farklı / the press time always differs
49 while (digitalRead(BUTTON_PINS[b]) == LOW);
50 delay(600);
51 return;
52 }
53 }
54 delay(10);
55 }
56 digitalWrite(LED_PINS[i], LOW);
57 i = (i + 1) % 4;
58 }
59}
60
61void endGame(uint16_t score) {
62 tone(BUZZER_PIN, 110, 700);
63 for (byte k = 0; k < 3; k++) { // tüm LED'ler yanıp söner / all LEDs flash
64 for (byte i = 0; i < 4; i++) digitalWrite(LED_PINS[i], HIGH);
65 delay(200);
66 for (byte i = 0; i < 4; i++) digitalWrite(LED_PINS[i], LOW);
67 delay(200);
68 }
69 if (score > hiScore) { hiScore = score; EEPROM.put(HISCORE_ADDR, hiScore); }
70 Serial.print(F("Seviye / Level: ")); Serial.print(score);
71 Serial.print(F(" Rekor / Best: ")); Serial.println(hiScore);
72 level = 0;
73 delay(1000);
74}
75
76void setup() {
77 for (byte i = 0; i < 4; i++) {
78 pinMode(LED_PINS[i], OUTPUT);
79 pinMode(BUTTON_PINS[i], INPUT_PULLUP); // basınca LOW / LOW when pressed
80 }
81 Serial.begin(9600);
82 EEPROM.get(HISCORE_ADDR, hiScore);
83 if (hiScore == 0xFFFF) hiScore = 0;
84}
85
86void loop() {
87 if (level == 0) waitForStart();
88 if (level == MAX_LEVEL) { endGame(MAX_LEVEL); return; } // hepsini bildin / you completed every level
89
90 sequence[level++] = random(4); // diziye yeni bir renk ekle / append a new colour
91 int showMs = max(180, 520 - level * 20); // seviye arttıkça hızlanır / faster at higher levels
92 for (byte i = 0; i < level; i++) { // diziyi baştan göster / replay the whole sequence
93 playColor(sequence[i], showMs);
94 delay(showMs / 2);
95 }
96 for (byte i = 0; i < level; i++) { // oyuncu aynı sırayı tekrarlar / the player repeats it
97 if (waitForButton() != sequence[i]) { // yanlış ya da geç / wrong or too late
98 endGame(level - 1);
99 return;
100 }
101 }
102 delay(700); // tur arası / pause between rounds
103}Bij Simon is willekeur alles: is de reeks in elke game hetzelfde, dan onthoudt de speler hem gewoon. De methode randomSeed(analogRead(A0)), die een niet-aangesloten pin leest, is in de praktijk zwak omdat de pin vaak vergelijkbare waarden geeft. Deze code gebruikt een robuustere truc: de game wacht op de eerste druk van de speler en gebruikt de waarde van micros() op dat moment als seed. Niemand kan het moment van een druk tot op de microseconde herhalen, dus elke game begint anders. De weergavetijd wordt per level 20 ms korter en komt uit op 180 ms; druk je binnen 3 seconden niet of druk je de verkeerde kleur, dan eindigt de game, en het bereikte level wordt bij een record in EEPROM opgeslagen.
LCD-runnergame: eigen tekens op een display van 16x2
Op een tekens-LCD van 16x2 kun je geen pixels tekenen, maar met createChar() definieer je tot 8 eigen tekens van elk 5×8 pixels. Drie zijn genoeg voor de runnergame: twee looppositures en een cactus. De onderste rij van het display is de grond; cactussen schuiven van rechts naar links, en als je op de knop drukt, gaat de runner naar de bovenste rij en blijft hij een paar stappen in de lucht. Omdat deze game op een raster is gebaseerd, is de botsingscontrole één regel: staat er een cactus in de kolom van de runner terwijl hij op de grond is, dan is het game over. Voor de bibliotheek en bedrading, zie I2C-LCD-display.
1#include <Wire.h>
2#include <EEPROM.h>
3#include <LiquidCrystal_I2C.h>
4
5LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x3F de olabilir / the address may also be 0x3F
6
7const byte JUMP_PIN = 3, BUZZER_PIN = 8;
8const int HISCORE_ADDR = 4; // EEPROM 4-5. bayt / EEPROM bytes 4-5
9const byte PLAYER_COL = 1; // koşucunun sütunu / runner's column
10const byte JUMP_STEPS = 4; // zıplama süresi (adım) / jump length (steps)
11const byte MIN_GAP = 4; // kaktüsler arası en az boşluk / minimum gap between cacti
12
13// 5x8 özel karakterler / 5x8 custom characters
14byte runA[8] = {0b01110, 0b01110, 0b00100, 0b01110, 0b10101, 0b00100, 0b01010, 0b10001};
15byte runB[8] = {0b01110, 0b01110, 0b00100, 0b01110, 0b10101, 0b00100, 0b01010, 0b01010};
16byte cactus[8] = {0b00100, 0b00101, 0b10101, 0b10101, 0b10110, 0b01100, 0b00100, 0b00100};
17
18byte ground[16]; // 1 = o sütunda kaktüs var / 1 = cactus in that column
19byte gap = 0, jumpLeft = 0;
20uint16_t score = 0, hiScore = 0;
21unsigned int stepMs = 300;
22unsigned long lastStep = 0;
23bool alive = false;
24
25// Sıçramasız basış: yalnız basıldığı an true / bounce-free: true only at the moment of a press
26bool buttonPressed() {
27 static bool stable = HIGH, lastRead = HIGH;
28 static unsigned long changedAt = 0;
29 bool r = digitalRead(JUMP_PIN);
30 if (r != lastRead) { lastRead = r; changedAt = millis(); }
31 if (millis() - changedAt > 15 && r != stable) {
32 stable = r;
33 return stable == LOW;
34 }
35 return false;
36}
37
38void draw() {
39 byte row = jumpLeft > 0 ? 0 : 1; // havadaysa üst satır / top row while jumping
40 lcd.setCursor(0, 0);
41 for (byte c = 0; c < 11; c++) lcd.write((uint8_t)(row == 0 && c == PLAYER_COL ? 0 : ' '));
42 char buf[6];
43 sprintf(buf, "%5u", score); // sağa yaslı skor / right-aligned score
44 lcd.print(buf);
45 lcd.setCursor(0, 1);
46 for (byte c = 0; c < 16; c++) {
47 if (row == 1 && c == PLAYER_COL) lcd.write((uint8_t)(score & 1)); // runA / runB sırayla / alternately
48 else lcd.write((uint8_t)(ground[c] ? 2 : ' '));
49 }
50}
51
52void startGame() {
53 memset(ground, 0, sizeof(ground));
54 gap = 0; jumpLeft = 0; score = 0; stepMs = 300;
55 alive = true;
56 lastStep = millis();
57 draw();
58}
59
60void die() {
61 alive = false;
62 tone(BUZZER_PIN, 150, 400);
63 if (score > hiScore) { hiScore = score; EEPROM.put(HISCORE_ADDR, hiScore); }
64 lcd.clear();
65 lcd.print(F("GAME OVER ")); lcd.print(score);
66 lcd.setCursor(0, 1);
67 lcd.print(F("BEST ")); lcd.print(hiScore);
68}
69
70void setup() {
71 pinMode(JUMP_PIN, INPUT_PULLUP);
72 lcd.init();
73 lcd.backlight();
74 lcd.createChar(0, runA);
75 lcd.createChar(1, runB);
76 lcd.createChar(2, cactus);
77 EEPROM.get(HISCORE_ADDR, hiScore);
78 if (hiScore == 0xFFFF) hiScore = 0;
79 randomSeed(analogRead(A3));
80 lcd.setCursor(0, 0); lcd.print(F("LCD RUNNER"));
81 lcd.setCursor(0, 1); lcd.print(F("BEST ")); lcd.print(hiScore);
82}
83
84void loop() {
85 if (buttonPressed()) {
86 if (!alive) startGame(); // başlat / start
87 else if (jumpLeft == 0) { // yerdeyse zıpla / jump only from the ground
88 jumpLeft = JUMP_STEPS;
89 tone(BUZZER_PIN, 1200, 20);
90 draw(); // zıplamayı hemen göster / show the jump at once
91 }
92 }
93 if (!alive || millis() - lastStep < stepMs) return;
94 lastStep = millis();
95
96 for (byte c = 0; c < 15; c++) ground[c] = ground[c + 1]; // dünya sola kayar / the world scrolls left
97 if (gap >= MIN_GAP && random(100) < 35) { ground[15] = 1; gap = 0; }
98 else { ground[15] = 0; gap++; }
99
100 if (jumpLeft > 0) jumpLeft--; // havada geçen bir adım / one step in the air
101 if (jumpLeft == 0 && ground[PLAYER_COL]) { die(); return; } // yerdeyken kaktüse çarptı / hit a cactus on the ground
102
103 score++;
104 if (score % 25 == 0 && stepMs > 120) stepMs -= 15; // giderek hızlan / speed up gradually
105 draw();
106}De wereld laten scrollen betekent dat je elk element van de grondarray één plek naar links kopieert; de meest rechtse kolom krijgt met 35% kans een nieuwe cactus. De regel MIN_GAP = 4 laat minstens vier lege kolommen tussen twee cactussen, zodat elk obstakel te nemen is. Elke 25 punten daalt de staptijd met 15 ms, van 300 ms naar 120 ms. Beide rijen bij elke stap opnieuw schrijven in plaats van het display te wissen met lcd.clear() voorkomt geflikker; het commando clear() alleen kost al ongeveer 2 ms. Zie je alleen blokjes op het scherm, draai dan aan de contrasttrimmer op de achterkant van de module; zie je helemaal niets, verander dan het adres van 0x27 naar 0x3F.
Reactietest: meet je reactietijd in milliseconden
Dit is de simpelste game en de meest verslavende: een led gaat op een willekeurig moment aan, jij drukt zo snel mogelijk op de knop en de Arduino print de verstreken tijd in milliseconden naar de Serial Monitor. Je hebt alleen een led op D7 met een weerstand van 220 Ω, de knop op D3 en een optionele buzzer nodig. De wachttijd is willekeurig, tussen 2 en 5 seconden; druk je tijdens het wachten, dan krijg je een waarschuwing "te vroeg", dus je kunt niet valsspelen door te gokken. De tijd wordt gemeten met micros(), je gemiddelde wordt berekend en je beste tijd wordt in EEPROM opgeslagen.
1#include <EEPROM.h>
2
3const byte LED_PIN = 7, BUTTON_PIN = 3, BUZZER_PIN = 8;
4const int BEST_ADDR = 6; // EEPROM 6-7. bayt / EEPROM bytes 6-7
5const bool USE_SOUND = false; // true: LED ile birlikte bip / true: beep together with the LED
6
7uint16_t best; // en iyi süre (ms); 0xFFFF = kayıt yok / best time (ms); 0xFFFF = none
8unsigned long total = 0;
9unsigned int rounds = 0;
10
11bool pressed() { return digitalRead(BUTTON_PIN) == LOW; }
12
13void waitRelease() {
14 while (pressed());
15 delay(50); // bırakma sıçramasını atla / skip the release bounce
16}
17
18void setup() {
19 pinMode(LED_PIN, OUTPUT);
20 pinMode(BUTTON_PIN, INPUT_PULLUP);
21 Serial.begin(9600);
22 EEPROM.get(BEST_ADDR, best); // boş EEPROM 0xFFFF = kayıt yok / blank EEPROM 0xFFFF = no record
23 Serial.println(F("Baslamak icin butona bas / Press the button to start"));
24}
25
26void loop() {
27 while (!pressed()); // başlatma basışı / start press
28 randomSeed(micros());
29 waitRelease();
30 Serial.println(F("Hazir ol... / Get ready..."));
31
32 unsigned long waitMs = random(2000, 5001); // 2-5 sn rastgele bekleme / random 2-5 s wait
33 unsigned long start = millis();
34 while (millis() - start < waitMs) {
35 if (pressed()) { // erken basış / false start
36 tone(BUZZER_PIN, 150, 500);
37 Serial.println(F("Erken bastin! / Too early!"));
38 waitRelease();
39 return;
40 }
41 }
42
43 unsigned long t0 = micros();
44 digitalWrite(LED_PIN, HIGH); // işaret / signal
45 if (USE_SOUND) tone(BUZZER_PIN, 2000, 50);
46 while (!pressed() && micros() - t0 < 2000000UL); // en fazla 2 sn bekle / wait at most 2 s
47 unsigned long ms = (micros() - t0) / 1000;
48 digitalWrite(LED_PIN, LOW);
49
50 if (ms >= 2000) {
51 Serial.println(F("Cok yavas / Too slow"));
52 return;
53 }
54 total += ms; rounds++;
55 Serial.print(F("Sure / Time: ")); Serial.print(ms);
56 Serial.print(F(" ms Ortalama / Average: ")); Serial.print(total / rounds);
57 Serial.println(F(" ms"));
58 if (ms < best) { // daha kısa süre daha iyi / shorter is better
59 best = ms;
60 EEPROM.put(BEST_ADDR, best);
61 tone(BUZZER_PIN, 1500, 150);
62 Serial.println(F("Yeni rekor! / New record!"));
63 }
64 Serial.print(F("Rekor / Best: ")); Serial.print(best); Serial.println(F(" ms"));
65 waitRelease();
66 delay(1000);
67}De gemiddelde menselijke reactietijd op licht is ongeveer 200–250 ms; een goed geconcentreerde speler kan er iets onder komen. Zet je USE_SOUND op true, dan klinkt er een piep samen met de led. Reacties op geluid zijn meestal iets sneller dan op licht, dus het vergelijken van de records van de twee modi is een interessant experiment. Toon de tijd op een 7-segmentdisplay of een oled in plaats van op de Serial Monitor en je hebt een apparaat op batterijen dat zonder computer werkt.
Games maken met de ESP32
Het grootste deel van de code in deze gids draait met kleine aanpassingen op de ESP32: de bibliotheken Adafruit SSD1306 en NeoPixel ondersteunen de ESP32, en tone() is beschikbaar in versie 2.x en 3.x van de ESP32 Arduino-core. Drie dingen moeten veranderen: de pins (de ESP32-kolom van de gedeelde tabel), de joystickdrempels en de manier waarop de highscore wordt opgeslagen. De ADC van de ESP32 is 12 bit en geeft waarden van 0 tot 4095, gebruik dus ongeveer 1200 en 2800 in plaats van 300 en 700. Sluit de joystick aan op de ADC1-pins, GPIO 32–39, omdat ADC2-pins niet te lezen zijn als Wi-Fi aan staat.
De ESP32 heeft geen echte EEPROM; de EEPROM-bibliotheek emuleert hem in flash en heeft de aanroepen EEPROM.begin() en EEPROM.commit() nodig. De nettere manier is de bibliotheek Preferences: die schrijft waarden onder een namespace en een sleutelnaam naar de NVS-partitie in flash en spreidt de slijtage zelf. De game "tap race" hieronder telt hoe vaak je in 5 seconden op de knop kunt drukken en slaat het record op met Preferences:
1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <Preferences.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1); // SDA = GPIO 21, SCL = GPIO 22
7Preferences prefs;
8
9const int BUTTON_PIN = 26; // aksiyon butonu / action button
10const int BUZZER_PIN = 27; // pasif buzzer / passive buzzer
11const unsigned long ROUND_MS = 5000; // 5 saniyelik tur / 5-second round
12
13uint32_t best = 0;
14
15// Sıçramasız basış: yalnız basıldığı an true / bounce-free: true only at the moment of a press
16bool buttonPressed() {
17 static bool stable = HIGH, lastRead = HIGH;
18 static unsigned long changedAt = 0;
19 bool r = digitalRead(BUTTON_PIN);
20 if (r != lastRead) { lastRead = r; changedAt = millis(); }
21 if (millis() - changedAt > 10 && r != stable) {
22 stable = r;
23 return stable == LOW;
24 }
25 return false;
26}
27
28void screen(const char *title, uint32_t big, uint32_t small) {
29 display.clearDisplay();
30 display.setTextSize(1);
31 display.setCursor(0, 0); display.print(title);
32 display.setCursor(0, 56); display.print("BEST "); display.print(best);
33 display.setTextSize(3);
34 display.setCursor(0, 20); display.print(big);
35 display.setTextSize(1);
36 display.setCursor(90, 56); display.print(small);
37 display.display();
38}
39
40void setup() {
41 pinMode(BUTTON_PIN, INPUT_PULLUP);
42 Serial.begin(115200);
43 if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
44 Serial.println("SSD1306 allocation failed");
45 for (;;) delay(1000);
46 }
47 display.setTextColor(SSD1306_WHITE);
48 prefs.begin("oyun", false); // "oyun" ad alanı, okuma-yazma / "oyun" namespace, read-write
49 best = prefs.getUInt("rekor", 0); // kayıt yoksa 0 / 0 when nothing is stored
50}
51
52void loop() {
53 screen("TAP RACE: PRESS", 0, 0);
54 while (!buttonPressed()) delay(1); // başlatma / start
55 for (int i = 3; i > 0; i--) { // 3-2-1 geri sayım / 3-2-1 countdown
56 screen("GET READY", i, 0);
57 tone(BUZZER_PIN, 800, 80);
58 delay(1000);
59 }
60 tone(BUZZER_PIN, 1600, 150);
61
62 uint32_t taps = 0;
63 unsigned long start = millis(), lastDraw = 0;
64 while (millis() - start < ROUND_MS) {
65 if (buttonPressed()) taps++;
66 if (millis() - lastDraw > 100) { // ekranı 10 kez/sn çiz / redraw 10 times per second
67 lastDraw = millis();
68 screen("TAP!", taps, (ROUND_MS - (millis() - start)) / 1000 + 1);
69 }
70 }
71
72 if (taps > best) { // yeni rekor flash'a / new record to flash
73 best = taps;
74 prefs.putUInt("rekor", best);
75 tone(BUZZER_PIN, 2000, 300);
76 }
77 screen("RESULT", taps, 0);
78 Serial.printf("Basis / Taps: %lu Rekor / Best: %lu\n", (unsigned long)taps, (unsigned long)best);
79 delay(3000);
80}prefs.getUInt("rekor", 0) geeft de tweede parameter terug als er niets is opgeslagen, dus je hoeft je nooit bezig te houden met het EEPROM-0xFFFF-probleem. Namespace- en sleutelnamen mogen maximaal 15 tekens lang zijn. Hoewel de processor van de ESP32 vele malen sneller is dan die van de Uno, gebruikt de oled dezelfde I2C-bus, dus de framerate verandert nauwelijks; voor veel vloeiender en kleurrijkere games kun je een SPI-ILI9341 TFT-display gebruiken. De Bluetooth van de ESP32 is dan weer een goed beginpunt om van een telefoon een gamecontroller te maken.
Games met de Raspberry Pi Pico en MicroPython
Programmeer je de Raspberry Pi Pico in MicroPython, dan is de gamelogica hetzelfde en verandert alleen de syntaxis: time.ticks_ms() en time.ticks_diff() in plaats van millis(), read_u16(), dat 0–65535 teruggeeft, in plaats van analogRead(), en PWM in plaats van tone(). De Pico heeft geen EEPROM, maar dankzij het bestandssysteem van MicroPython is het heel makkelijk het record naar een klein tekstbestand in flash te schrijven. De code hieronder is de Pico-versie van de reactietest en bewaart het record in het bestand rekor.txt; sla hem in Thonny op het board op als main.py en hij start bij elke keer opstarten vanzelf. Ben je nieuw met MicroPython, lees dan eerst Wat is de Raspberry Pi Pico?
1from machine import Pin, PWM
2import time, random
3
4led = Pin("LED", Pin.OUT) # kart üstündeki LED / onboard LED
5button = Pin(14, Pin.IN, Pin.PULL_UP) # GP14, basınca 0 / 0 when pressed
6buzzer = PWM(Pin(16)) # GP16, pasif buzzer / passive buzzer
7buzzer.duty_u16(0) # başlangıçta sessiz / silent at start
8FILE = "rekor.txt" # rekor flash'ta dosyada / record kept in a file on flash
9
10def beep(freq, ms):
11 buzzer.freq(freq)
12 buzzer.duty_u16(32768) # %50 görev oranı / 50% duty cycle
13 time.sleep_ms(ms)
14 buzzer.duty_u16(0)
15
16def load_best():
17 try:
18 with open(FILE) as f:
19 return int(f.read())
20 except (OSError, ValueError): # dosya yok ya da bozuk / file missing or corrupt
21 return 99999
22
23def save_best(ms):
24 with open(FILE, "w") as f:
25 f.write(str(ms))
26
27def wait_release():
28 while button.value() == 0:
29 time.sleep_ms(5)
30 time.sleep_ms(50) # bırakma sıçraması / release bounce
31
32best = load_best()
33print("Baslamak icin butona bas / Press the button to start")
34
35while True:
36 while button.value() == 1: # başlatma basışı / start press
37 time.sleep_ms(5)
38 wait_release()
39 print("Hazir ol... / Get ready...")
40
41 wait = random.randint(2000, 5000) # 2-5 sn rastgele bekleme / random 2-5 s wait
42 start = time.ticks_ms()
43 early = False
44 while time.ticks_diff(time.ticks_ms(), start) < wait:
45 if button.value() == 0:
46 early = True
47 break
48 if early:
49 print("Erken bastin! / Too early!")
50 beep(150, 400)
51 wait_release()
52 continue
53
54 t0 = time.ticks_us()
55 led.on() # işaret / signal
56 while button.value() == 1 and time.ticks_diff(time.ticks_us(), t0) < 2000000:
57 pass
58 ms = time.ticks_diff(time.ticks_us(), t0) // 1000
59 led.off()
60
61 if ms >= 2000:
62 print("Cok yavas / Too slow")
63 continue
64 print("Sure / Time:", ms, "ms")
65 if ms < best: # daha kısa süre daha iyi / shorter is better
66 best = ms
67 save_best(best)
68 print("Yeni rekor! / New record!")
69 beep(1500, 150)
70 print("Rekor / Best:", best, "ms")
71 wait_release()
72 time.sleep(1)ticks_diff() gebruiken bij het meten van tijd is belangrijk: de tellers lopen na een bepaalde waarde rond, en twee waarden simpelweg van elkaar aftrekken geeft op dat moment een verkeerd resultaat; ticks_diff() verwerkt het rondlopen correct. Voor oled-games biedt het ssd1306-stuurprogramma dat je installeert via de pakketbeheerder van Thonny de commando's fill_rect(), text() en show(), vergelijkbaar met Adafruit GFX. De module neopixel die je nodig hebt voor een NeoPixel-matrix zit standaard in MicroPython. Zo kun je Pong en Snake met dezelfde logica naar de Pico overzetten.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| Leeg scherm | Toont de Serial Monitor "SSD1306 allocation failed", dan is het RAM op; zo niet, dan klopt het adres of de bedrading niet | Zet vaste tekst in F() en maak grote arrays kleiner; zonder de melding controleer je de SDA/SCL-draden en probeer je adres 0x3D |
| De game begint elke keer hetzelfde | Geen randomSeed() of altijd dezelfde seed | Gebruik als seed de waarde van micros() bij de eerste druk van de speler |
| Eén druk laat hem twee keer springen | Contactdender van de knop | Gebruik de functie buttonPressed() die op 15 ms stabiliteit wacht |
| De highscore toont 65535 | EEPROM die nooit is beschreven leest 0xFF | Behandel 0xFFFF als 0 |
| Het personage drijft weg als de joystick wordt losgelaten | Het midden is niet 512 en de dode zone is te smal | Houd de drempels 300/700 aan of meet het midden bij het opstarten en kalibreer |
| De slang springt diagonaal | De matrix is in zigzag bedraad | Zet SERPENTINE = true |
| De Arduino reset als de helderheid omhooggaat | De ledmatrix trekt te veel stroom | Verlaag setBrightness() en gebruik een externe voeding van 5 V |
| PWM op pin 3 of 11 haapert als tone() speelt | Op de Uno gebruikt tone() Timer2 | Verplaats het onderdeel dat PWM nodig heeft naar pin 5, 6, 9 of 10 |
| De game wordt langzamer naarmate hij vordert | Serial.print of onnodig tekenen in elk frame | Haal de seriële uitvoer weg en houd de frametijd boven de overdrachtstijd van het display |
| De LCD toont alleen blokjes | Contrastinstelling of verkeerd adres | Draai aan de trimmer op de achterkant en probeer adres 0x27 of 0x3F |
Ideeën om je games verder te brengen
- Pong voor twee spelers: verwijder de CPU-regels, bestuur de tweede paddle met een potmeter op A2 en leid beide besturingen op lange draden naar tegenovergestelde uiteinden van de tafel.
- Kantelbesturing: gebruik een MPU6050 in plaats van de joystick en stuur de slang of de paddle door het board te kantelen.
- Muziek en geluidseffecten: speel gamemuziek af met een DFPlayer Mini; voor korte effecten is een passieve buzzer genoeg.
- Spelen vanaf je telefoon: maak van je telefoon een draadloze controller met een HC-05 Bluetooth-module.
- Een gamepad voor je computer: omdat de Arduino Leonardo zich als USB-toetsenbord kan gedragen, kun je met een joystick en knoppen een controller voor pc-games bouwen.
- Scorebord: toon de highscores als scrollende tekst op een 4-in-1 MAX7219-module.
- Kansspelen: bouw een roulettewiel met een WS2812B-ring of een elektronische dobbelsteen met leds; de leukste manier om random() te oefenen.
Games maken met Arduino is de plezierigste manier om code en hardware tegelijk te leren. Heb je de gameloop, botsingsdetectie en de EEPROM-highscore eenmaal begrepen, dan hoef je alleen nog een idee te hebben om je eigen game te ontwerpen; voor meer inspiratie bekijk je de lijst met Arduino-projectideeën. In de BlueGrays-app vind je Pong, de oled-T-Rex, Snake op een 8x8- en 16x16-matrix, Simon, de LCD-runner en de reactietest als stap-voor-stapprojecten met schakelschema's en kant-en-klare code.
Veelgestelde vragen
Welke games kun je maken met een Arduino?
Met een Arduino Uno kun je Pong, de T-Rex-runner, games in de stijl van Flappy Bird, Snake, simpele blokkengames, het geheugenspel Simon, een reactietest en kansspelen zoals dobbelstenen of roulette maken. Een oled van 128×64 is genoeg voor games met graphics en een NeoPixel-ledmatrix voor kleurrijke rastergames. Games als Simon en de reactietest speel je met alleen leds en knoppen, zonder display.
Wat is het beste display voor een Arduino-game?
Voor beginners is de beste keuze de 0,96-inch SSD1306 oled: hij is goedkoop, wordt met slechts twee datadraden aangesloten en tekent bewegende graphics op 128×64 pixels. Wil je een groter kleurenbeeld, dan past een ILI9341- of ST7789-TFT-display, en voor pixelartgames een ledmatrix van 8x8 of 16x16. Een LCD van 16x2 met eigen tekens is ook genoeg voor simpele runnergames.
Hoe sla je een highscore op met Arduino?
Schrijf je de highscore naar EEPROM, dan gaat hij niet verloren als de stroom uitvalt. Je schrijft hem met EEPROM.put(address, score) en leest hem met EEPROM.get(address, score); de Arduino Uno heeft hiervoor 1024 bytes. Omdat elke cel ongeveer 100.000 keer kan worden beschreven, schrijf je alleen als de game voorbij is en het record is verbroken.
Kun je een gamepad maken met een Arduino?
Ja. Boards met de ATmega32U4-processor, zoals de Arduino Leonardo, Micro of Pro Micro, kunnen zich voor de computer voordoen als USB-toetsenbord, muis of gamecontroller; ze lezen de joystick en knoppen en sturen toetsaanslagen. De Arduino Uno kan dit niet rechtstreeks, maar kan wel de joystickwaarden via de seriële poort naar een programma op de computer sturen.
Waarom is mijn Arduino-game traag of laggy?
De meest voorkomende oorzaken zijn lussen met delay(), Serial.print-aanroepen in elk frame en de overdrachtstijd van het display. Op de Uno duurt het versturen van het hele oled-scherm ongeveer 25 ms, dus een frametijd van 30 ms is realistisch. Gebruik een vaste frametijd met millis() in plaats van delay(), haal seriële uitvoer weg en teken alleen wat nodig is.
Wat is de makkelijkste Arduino-game voor beginners?
De reactietest is het makkelijkst: je hebt één led, één knop en een korte sketch nodig, en toch leert hij kernideeën als timing, willekeurige getallen en EEPROM. Daarna is doorgaan naar Simon met vier leds en vier knoppen, en dan naar Pong en T-Rex op een oled-display, een goed leertraject.
Projecten om hierna te bouwen
Alle projecten bekijken
Paddleballspel - SSD1306
Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.

OLED T-Rex Run: Arduino-dinosaurusspel
Het dinosaurusspel dat verschijnt als je internet wegvalt, nu op je bureau: de dinosaurus rent over het kleine OLED-scherm, cactussen komen op je af en jij springt met één knop.

Pixelslang 8x8-matrix
Bouw het klassieke slangenspel zelf en speel het. Op een kleurrijke 8x8-lichtmatrix stuur je met een joystick een groene slang en eet je rode appels.

Matrixslang 16x16
Het klassieke slangenspel, nu op een enorm ledscherm van 256 lichtjes. Je stuurt de groene slang met een joystick en verzamelt rode appels.

Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)
Vertrouw je op je geheugen? Vier gekleurde leds lichten na elkaar op en spelen elk hun eigen toon; jij herhaalt dezelfde volgorde door op de knoppen te drukken.

Arduino-lcd-runnerspel
Zijwaarts scrollend endless-runnerspel op een 16x2-tekens-lcd. De held rent vanzelf en de speler springt over obstakels met een druk op de knop. Op de bovenste en onderste regel verschijnen willekeurige obstakels. Een passieve buzzer speelt een openingsmelodie, een springgeluid, een feestgeluid bij 50 punten en een eindmelodie. Bij het opstarten verschijnt "BlueGrays - Arduino Projects". De score staat rechtsboven.

Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)
Hoe snel zijn je reflexen? Druk op de knop: rood zegt maak je klaar, geel zegt wacht, en er begint een willekeurige wachttijd van 1,5 tot 3,5 seconden. Gaat de groene led aan en piept de buzzer, druk dan opnieuw; je reactietijd verschijnt in milliseconden op de I2C-LCD, met je beste en gemiddelde tijd. Druk je vóór groen, dan toont het scherm TOO EARLY! (te vroeg) met een verliesgeluid. Houd de knop ingedrukt voor een nieuwe speler.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

