Gidsen · 19 min leestijd

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.

Arduino Snake-game op een 8x8 NeoPixel-ledmatrix
8x8 WS2812B NeoPixel-ledmatrix: 64 kleurenpixels en één datadraad, een ideaal minischermpje voor een Snake-game.

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:

GameDisplayInvoerOverige onderdelenNiveau
Reactietest1 led + Serial Monitor1 knop220 Ω-weerstand, optioneel een buzzerMakkelijk
Simon-geheugenspel4 gekleurde leds4 knoppen4 × 220 Ω-weerstanden, passieve buzzerMakkelijk–gemiddeld
LCD-runner16x2 I2C LCD1 knopPassieve buzzerGemiddeld
Pong0,96" SSD1306 oledJoystick of 10 kΩ-potmeterPassieve buzzerGemiddeld
T-Rex-runner0,96" SSD1306 oled1 knop of de joystickknopPassieve buzzerGemiddeld
Snake (8x8)8x8 NeoPixel-matrixJoystick330 Ω-weerstand, 1000 µF-condensatorGemiddeld–gevorderd
Snake (16x16)16x16 NeoPixel-matrixJoystickExterne voeding van 5 V, 3–4 AGevorderd
Arduino Uno
Arduino Uno
OLED SSD1306 0.96"
OLED SSD1306 0.96"
Joystick
Joystick
LCD 16x2 I2C
LCD 16x2 I2C
Buzzer
Buzzer
Push button
Push button

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 / pinArduino UnoESP32Raspberry Pi Pico
Oled of I2C-LCD: SDAA4GPIO 21GP4
Oled of I2C-LCD: SCLA5GPIO 22GP5
Joystick VRx (X-as)A0GPIO 34GP26
Joystick VRy (Y-as)A1GPIO 35GP27
Joystick SW (knop)D2GPIO 25GP15
Actieknop (andere pootje naar GND)D3GPIO 26GP14
Passieve buzzer (+)D8GPIO 27GP16
NeoPixel DIN (via 330 Ω)D6GPIO 13GP22
Voed de joystick en de oled op de ESP32 en de Pico met 3,3 V; een joystick die op 5 V draait zet meer dan 3,3 V op de analoge pins en kan het board beschadigen. Sluit je een 5V-I2C-LCD-module aan op een ESP32, plaats dan een niveauconverter ertussen. Alle knoppen gebruiken de interne pull-upweerstand: één pootje gaat naar de pin, het andere naar GND, en de pin leest LOW als je indrukt.

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:

C++ (Arduino IDE)
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.

GameWat botst met wat?Methode
PongBal met de muren en paddlesAABB + de snelheid omkeren
T-RexDinosaurus met de cactussenAABB (met een iets kleinere box)
SnakeKop met de muren, het lichaam en het voerGelijkheid van rastercellen
LCD-runnerRunner met een cactusZelfde kolom en zelfde rij
SimonIngedrukte kleur met de kleur in de reeksVergelijking van arrayelementen
ReactietestDrukmoment met signaalmomentTijdsvergelijking (valse start)
Kleine, snel bewegende objecten kunnen in één frame dwars door een obstakel heen gaan en de botsing overslaan; dit heet tunnelen. Beweegt de bal in Pong meer dan 4 pixels per frame, dan steekt hij de controlezone van de paddle van 3 pixels over zonder hem ooit te raken. De oplossing is de snelheid per frame van het object kleiner te houden dan de breedte van de controlezone, en precies dat doet de limiet MAX_SPEED = 2.8 in de Pong-code.

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.

C++ (Arduino IDE)
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:

GameEEPROM-adresOpgeslagen waarde
T-Rex-runner0–1Hoogste score
Snake2–3Meeste voer gegeten
LCD-runner4–5Hoogste score
Reactietest6–7Kortste tijd (ms)
Simon8–9Hoogste 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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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}
InstellingWaardeEffect
JUMP_V-4.2Sprongkracht; bij -5 klimt de dinosaurus ongeveer 40 pixels, dicht bij de bovenkant van het scherm
GRAVITY0.3Een grotere waarde maakt de sprong korter en scherper
speed2.0 → 5.0Snelheid van de cactussen; groeit elke 200 frames met 0.25
random(70, 140)pixelsAfstand tussen twee cactussen; kleinere waarden maken de game moeilijker
Hitbox10×12 pixelsKleiner 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.

C++ (Arduino IDE)
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.

16x16 NeoPixel-ledmatrix
16x16 NeoPixel-matrix: een speelveld van 256 pixels betekent een langere slang en een pittigere game; er is een externe voeding van 5 V nodig.
Een enkele WS2812B trekt bij volledig wit ongeveer 60 mA; de 256 leds van een 16x16-matrix kunnen in het slechtste geval 15 A halen, en dat kunnen noch USB noch de 5V-pin van de Arduino leveren. Voed de matrix met een externe voeding van 5 V en 3–4 A, verbind de GND van de voeding met de GND van de Arduino en plaats een weerstand van 330 Ω op de datalijn en een condensator van 1000 µF over de voedingsingang. setBrightness(30) in de code verlaagt de helderheid tot ongeveer 12%; omdat bij Snake maar een paar leds tegelijk branden, blijft de stroom op een paar honderd mA. Voor een enkelkleurige variant die minder RAM gebruikt, zie MAX7219-ledmatrix.

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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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:

C++ (Arduino IDE)
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?

MicroPython
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

SymptoomOorzaakOplossing
Leeg schermToont de Serial Monitor "SSD1306 allocation failed", dan is het RAM op; zo niet, dan klopt het adres of de bedrading nietZet 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 hetzelfdeGeen randomSeed() of altijd dezelfde seedGebruik als seed de waarde van micros() bij de eerste druk van de speler
Eén druk laat hem twee keer springenContactdender van de knopGebruik de functie buttonPressed() die op 15 ms stabiliteit wacht
De highscore toont 65535EEPROM die nooit is beschreven leest 0xFFBehandel 0xFFFF als 0
Het personage drijft weg als de joystick wordt losgelatenHet midden is niet 512 en de dode zone is te smalHoud de drempels 300/700 aan of meet het midden bij het opstarten en kalibreer
De slang springt diagonaalDe matrix is in zigzag bedraadZet SERPENTINE = true
De Arduino reset als de helderheid omhooggaatDe ledmatrix trekt te veel stroomVerlaag setBrightness() en gebruik een externe voeding van 5 V
PWM op pin 3 of 11 haapert als tone() speeltOp de Uno gebruikt tone() Timer2Verplaats het onderdeel dat PWM nodig heeft naar pin 5, 6, 9 of 10
De game wordt langzamer naarmate hij vordertSerial.print of onnodig tekenen in elk frameHaal de seriële uitvoer weg en houd de frametijd boven de overdrachtstijd van het display
De LCD toont alleen blokjesContrastinstelling of verkeerd adresDraai aan de trimmer op de achterkant en probeer adres 0x27 of 0x3F
Gedraagt een game zich niet zoals je verwacht, test dan eerst de logica zonder het display: print elk frame de positie, snelheid en toestand naar de Serial Monitor en volg een paar frames met de hand. Heb je de bug gevonden, verwijder die regels dan, want Serial.print kost een paar milliseconden per frame en verstoort de gamesnelheid. Wil de code helemaal niet naar het board uploaden, bekijk dan de gids Arduino-code wordt niet geüpload.

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.

Alle projecten bekijken
Paddleballspel - SSD1306
AR-86Gemiddeld
Premium

Paddleballspel - SSD1306

Een bal, twee batjes en jij: op een klein OLED-scherm speel je tafeltennis, een van de allereerste videogames.

4.5(47)
65
OLED T-Rex Run: Arduino-dinosaurusspel
AR-87Gevorderd
Premium

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.

4.7(33)
53
Pixelslang 8x8-matrix
AR-88Gevorderd
Premium

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.

4.7(39)
57
Matrixslang 16x16
AR-89Gevorderd
Premium

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.

4.8(52)
67
Arduino-geheugenspel (4 leds + 4 knoppen + buzzer)
AR-93Gevorderd
Premium

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.

4.8(46)
69
Arduino-lcd-runnerspel
AR-96Gemiddeld
Premium

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.

4.6(32)
56
Arduino-reactietest met geluidssignaal: meet je reflexen in milliseconden (LCD + buzzer + 3 leds)
AR-95Gemiddeld
Premium

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.

4.6(33)
50