Arduino

Details: Kategorie: Arduino; Erstellt: 26. März 2026; Zugriffe: 10

Du kennst den klassischen UNO, aber der R4 WiFi spielt in einer ganz anderen Liga. Er vereint die vertraute Bauweise mit der Power eines 32-Bit-Mikroprozessors und bringt dank des integrierten ESP32-Moduls direkt WLAN und Bluetooth mit. Damit wird dein Projekt vom einfachen Stand-alone-Gerät zum echten IoT-Device.

Der Arduino UNO R4 WiFi: Dein Upgrade in die vernetzte Welt

Was diesen kleinen Chip so besonders macht? Neben der Rechenpower ist es vor allem die eingebaute 12x8 LED-Matrix, mit der du ohne zusätzliche Displays Texte, Icons und Animationen direkt auf dem Board anzeigen kannst. Egal ob du Sensordaten in die Cloud schicken, dein Smartphone als Fernsteuerung nutzen oder komplexe Berechnungen anstellen willst der R4 WiFi bietet dir die nötige Performance. Für die präzise Steuerung über den Encoder nutzen wir meine eigene K4_ENC Bibliothek, die perfekt auf die Performance des R4 abgestimmt ist.

Auf dieser Seite zeige ich dir 20 kreative Ideen, mit denen du das volle Potenzial dieses Kraftpakets ausschöpfen kannst. Vom vernetzten Lautstärkeregler für deinen PC bis hin zum globalen digitalen Würfel entdecke, wie du mit minimalem Hardware-Einsatz beeindruckende Projekte realisierst!

10 Projekte ohne externe Bauteile (nur mit Encoder)

Analoguhr: Der Klassiker, eine Analoguhr mit Stunde und Minute, gespeichert durch die interne RTC und den VRTC Pin, sollte die mal nicht stimmen, drücke 5 Sekunden den Taster, des Encoders.
Space Invaders: S Das unsterbliche arcarde Spiel, bewege dein Raumschiff mit dem Encoder durch die Feindlichen Raumschiffe.
Snake: Ein weitere Spieleklassiker, durch drehen nach link und rechts, bewegt sich deine Schlange durch das Spielfeld.
Digitaler Würf el: Würfelfunktion (1-6) per Knopfdruck, als Würfelaugen mit Animation.
Lotto Generator: Einfaches Lotto mit 6 aus 49 mit Superzahl. Die Zahler werden der Reihe nach angezeigt und erscheinen zusätzlich im Serial Monitor.
Reaction Timer: Die Matrix leuchtet auf, und du musst so schnell wie möglich den Encoder drücken.
Metronom: Ein taktgebendes Lichtsignal für Musiker (Tempo via Encoder).
Klick-Zähler: Einfaches Tool zum Zählen von Dingen (z.B. Personen im Raum). Rechts drehen +1, links drehen -1, Tasterdruck reset auf 0.
Stoppuhr: Einfache Stoppuhr bis 999 Sekunden, im Serial Monitor werden zusätzlich die Zentel Sekunden angezeigt.
Buchstaben-Regen (Matrix-Style): Eine rein visuelle Animation zur Deko.

10 Projekte mit Standard-Hardware (Sensoren/Aktoren)

Raumklima-Station: Anzeige von Temperatur und Feuchtigkeit (DHT11/22) im Wechsel.
Abstands-Warner: Nutzt einen HC-SR04; die Matrix füllt sich, je näher ein Objekt kommt.
Licht-Ometer: Ein LDR misst die Helligkeit und regelt die Matrix-Intensität oder zeigt Lux-Werte.
Bodenfeuchte-Wächter: Ein Sensor in der Pflanze zeigt via Matrix (Smiley oder Balken), ob gegossen werden muss.
Digitales Lineal: Mit einem Ultraschallsensor Entfernungen messen und direkt anzeigen.
Alarmanlage: Ein PIR-Bewegungssensor löst ein blinkendes "X" oder ein Warnsignal aus.
Musik-Visualizer: Ein Mikrofon-Modul lässt die Matrix im Takt der Musik ausschlagen.
Laser-Schranke: Zählt, wie oft ein Laserstrahl unterbrochen wurde.
RFID-Namensschild: Zeigt je nach erkanntem Tag unterschiedliche Namen oder Symbole an.
Servotester: Ein Poti steuert einen Servo, die Matrix zeigt den aktuellen Winkel (0-180°).
CO2-Ampel: Mit einem MQ-135 Sensor die Luftqualität visualisieren (Grün/Gelb/Rot Muster).
Lüfter-Steuerung: Temperaturabhängige Drehzahlmessung eines PC-Lüfters.
Neigungssensor-Spiel: Ein physikalisches Labyrinth, bei dem man einen "Pixel" durch Kippen steuert.
Waage: Mit einer Load Cell (Wägezelle) das Gewicht in Gramm klein anzeigen.
Fernbedienungs-Decoder: Empfängt IR-Signale und zeigt den Hex-Code der Taste an.

1 Der Arduino R4 WIFI Code für die Analoguhr

#include "Arduino_LED_Matrix.h"
#include "RTC.h"
#include <K4_ENC.h>

ArduinoLEDMatrix matrix;
K4_ENC enc; 

const int BUTTON_PIN = 4; 

// Zeit-Variablen
int setHours = 0;
int setMinutes = 0;

// Zustände
const int STATE_SET_HOURS = 0;
const int STATE_SET_MINUTES = 1;
const int STATE_RUNNING = 2;
int currentState = STATE_RUNNING; 

// Long Press Variablen
unsigned long buttonPressedStartTime = 0;
bool isHolding = false;
const int LONG_PRESS_DURATION = 5000; 

// Koordinaten für das 12x8 Ziffernblatt
const int clockPoints[12][2] = {
  {5, 0}, {8, 0}, {10, 1}, {11, 3}, {10, 6}, {8, 7}, 
  {6, 7}, {3, 7}, {1, 6}, {0, 4}, {1, 1}, {3, 0}
};

const uint8_t digits[10][5] = {
  {0x7, 0x5, 0x5, 0x5, 0x7}, {0x2, 0x2, 0x2, 0x2, 0x2},
  {0x7, 0x1, 0x7, 0x4, 0x7}, {0x7, 0x1, 0x7, 0x1, 0x7},
  {0x5, 0x5, 0x7, 0x1, 0x1}, {0x7, 0x4, 0x7, 0x1, 0x7},
  {0x7, 0x4, 0x7, 0x5, 0x7}, {0x7, 0x1, 0x1, 0x1, 0x1},
  {0x7, 0x5, 0x7, 0x5, 0x7}, {0x7, 0x5, 0x7, 0x1, 0x1}
};

void setCompileTime() {
  char const *compileTime = __TIME__; 
  int hour, minute, second;
  sscanf(compileTime, "%d:%d:%d", &hour, &minute, &second);
  RTCTime timeToSet(26, Month::MARCH, 2026, hour, minute, second, DayOfWeek::THURSDAY, SaveLight::SAVING_TIME_INACTIVE);
  RTC.setTime(timeToSet);
}

void setup() {
  Serial.begin(9600);
  matrix.begin();
  enc.begin();
  RTC.begin();
  
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  setCompileTime();
}

void loop() {
  enc.update();
  bool buttonIsDown = (digitalRead(BUTTON_PIN) == LOW);

  // --- Logik für 5-Sekunden-Druck (Reset) ---
  if (currentState == STATE_RUNNING) {
    if (buttonIsDown) {
      if (!isHolding) {
        buttonPressedStartTime = millis();
        isHolding = true;
      }
      if (millis() - buttonPressedStartTime >= LONG_PRESS_DURATION) {
        // Feedback: Matrix kurz voll an
        uint8_t flash[8][12];
        memset(flash, 1, sizeof(flash));
        matrix.renderBitmap(flash, 8, 12);
        
        // Warten auf Loslassen
        while(digitalRead(BUTTON_PIN) == LOW) { delay(10); }
        
        // Encoder-Status "auffressen", damit kein Sprung passiert
        enc.update();
        enc.isPressed(); 
        enc.clear();
        
        // In Einstellmodus wechseln
        RTCTime now;
        RTC.getTime(now);
        setHours = now.getHour();
        setMinutes = now.getMinutes();
        
        currentState = STATE_SET_HOURS;
        isHolding = false;
        delay(200);
      }
    } else {
      isHolding = false;
    }
  }

  // --- State Machine ---
  if (currentState == STATE_SET_HOURS) {
    int val = enc.getCount();
    if (val != 0) {
      setHours = (setHours + val + 24) % 24;
      enc.clear();
    }
    displayNumber(setHours);

    if (enc.isPressed()) {
      enc.clear(); 
      currentState = STATE_SET_MINUTES;
      delay(300); 
    }
  } 
  else if (currentState == STATE_SET_MINUTES) {
    int val = enc.getCount();
    if (val != 0) {
      setMinutes = (setMinutes + val + 60) % 60;
      enc.clear();
    }
    displayNumber(setMinutes);

    if (enc.isPressed()) {
      RTCTime now;
      RTC.getTime(now);
      RTCTime newTime(now.getDayOfMonth(), now.getMonth(), now.getYear(), setHours, setMinutes, 0, now.getDayOfWeek(), SaveLight::SAVING_TIME_INACTIVE);
      RTC.setTime(newTime);
      currentState = STATE_RUNNING;
      delay(300);
    }
  } 
  else if (currentState == STATE_RUNNING) {
    updateAndDrawClock();
  }
}

void displayNumber(int num) {
  uint8_t frame[8][12] = {0};
  int tens = num / 10;
  int units = num % 10;
  for (int y = 0; y < 5; y++) {
    for (int x = 0; x < 3; x++) {
      if ((digits[tens][y] >> (2 - x)) & 0x1) frame[y + 1][x + 2] = 1;
      if ((digits[units][y] >> (2 - x)) & 0x1) frame[y + 1][x + 7] = 1;
    }
  }
  matrix.renderBitmap(frame, 8, 12);
}

void updateAndDrawClock() {
  RTCTime now;
  if (!RTC.getTime(now)) return;
  
  int h = now.getHour() % 12; 
  int mIdx = now.getMinutes() / 5; 

  uint8_t frame[8][12] = {0};
  for (int i = 0; i < 12; i++) {
    frame[clockPoints[i][1]][clockPoints[i][0]] = 1;
  }
  drawHandLine(frame, clockPoints[mIdx][0], clockPoints[mIdx][1], true); 
  drawHandLine(frame, clockPoints[h][0], clockPoints[h][1], false);     
  matrix.renderBitmap(frame, 8, 12);
}

void drawHandLine(uint8_t f[8][12], int tx, int ty, bool isLong) {
  const int cx = 5; 
  const int cy = 3; 
  f[cy][cx] = 1;
  int steps = isLong ? 4 : 2; 
  for (int i = 1; i <= steps; i++) {
    int px = cx + (tx - cx) * i / steps;
    int py = cy + (ty - cy) * i / steps;
    f[py][px] = 1;
  }
}

2 Der Arduino R4 WIFI Code für das Space Invaders Spiel

#include "Arduino_LED_Matrix.h"
#include <K4_ENC.h>

ArduinoLEDMatrix matrix;
K4_ENC enc; // Default Pins: 2, 3 (Encoder) und 4 (Taster)

const int matrixWidth = 12;
const int matrixHeight = 8;
const unsigned long gameSpeedStart = 200; // Startgeschwindigkeit

// Puffer für das Spielfeld (Bitmap)
uint8_t frame[8][12]; 

// Spiel-Variablen
int playerY = 4;
bool enemies[8][12];
unsigned long lastMoveTime = 0;
unsigned long gameSpeed = gameSpeedStart;
bool gameActive = false;
bool gameOver = false;

// Zähler für die Geschwindigkeits-Erhöhung
int moveCounter = 0;

void setup() {
  Serial.begin(9600);
  matrix.begin();
  enc.begin();
  
  randomSeed(analogRead(0));
  
  // Zeige den Bereit-Zustand (nur das Raumschiff)
  showReadyScreen();
}

void loop() {
  enc.update(); // Background work for encoder and button

  // Wenn der Taster gedrückt wird
  if (enc.isPressed()) {
    if (gameOver) {
      resetGame(); // Setzt alles zurück und startet sofort
    } else {
      gameActive = !gameActive;
      if (gameActive) Serial.println("Spiel gestartet!");
      else Serial.println("Spiel pausiert.");
    }
  }

  // Spiellogik läuft nur, wenn aktiv und nicht Game Over
  if (gameActive && !gameOver) {
    handleMovement();
    handleEnemies();
    drawFrame();
  }
}

void handleMovement() {
  int val = enc.getCount();
  playerY = val % matrixHeight;
  if (playerY < 0) playerY += matrixHeight; 
}

void handleEnemies() {
  if (millis() - lastMoveTime > gameSpeed) {
    lastMoveTime = millis();
    moveCounter++; // Zähle jede Verschiebung

    // 1. Gegner verschieben
    for (int y = 0; y < matrixHeight; y++) {
      for (int x = 0; x < matrixWidth - 1; x++) {
        enemies[y][x] = enemies[y][x + 1];
      }
      enemies[y][matrixWidth - 1] = false;
    }

    // 2. Kollision überprüfen (NEU: Prüfe beide LEDs des Raumschiffs!)
    if (enemies[playerY][0] || enemies[playerY][1]) {
      endGame();
      return; // Sofort abbrechen!
    }

    // 3. Neue Gegner spawnen
    if (random(0, 10) > 7) { 
      enemies[random(0, matrixHeight)][matrixWidth - 1] = true;
    }
    
    // 4. Geschwindigkeit langsam erhöhen (Alle 5 Verschiebungen)
    if (moveCounter % 5 == 0 && gameSpeed > 60) {
      gameSpeed -= 1;
    }
  }
}

void drawFrame() {
  // 1. Spielfeld komplett löschen
  for (int y = 0; y < matrixHeight; y++) {
    for (int x = 0; x < matrixWidth; x++) frame[y][x] = 0; 
  }

  // 2. Spieler-Raumschiff setzen (Spalte 0 UND 1, Zeile playerY)
  if (playerY >= 0 && playerY < matrixHeight) {
    frame[playerY][0] = 1;
    frame[playerY][1] = 1;
  }

  // 3. Gegner zeichnen
  for (int y = 0; y < matrixHeight; y++) {
    for (int x = 0; x < matrixWidth; x++) {
      if (enemies[y][x]) {
        frame[y][x] = 1;
      }
    }
  }

  // 4. Das Bild auf die Matrix schieben
  matrix.renderBitmap(frame, 8, 12);
}

void clearEnemies() {
  for (int y = 0; y < matrixHeight; y++) {
    for (int x = 0; x < matrixWidth; x++) enemies[y][x] = false;
  }
}

// Hilfsfunktion zum sicheren Setzen von Pixeln im Frame-Puffer
void setPixel(int x, int y) {
  if (x >= 0 && x < matrixWidth && y >= 0 && y < matrixHeight) {
    frame[y][x] = 1;
  }
}

// Hilfsfunktion zum Löschen des Frames
void clearFrame() {
  for (int y = 0; y < matrixHeight; y++) {
    for (int x = 0; x < matrixWidth; x++) frame[y][x] = 0;
  }
}

void endGame() {
  gameActive = false;
  gameOver = true;
  Serial.println("Kollision! GAME OVER!");

  // --- NEU: DIE EXPLOSIONS-ANIMATION ---
  // Wir nutzen playerY als Zentrum der Explosion

  // Schritt 1: Der Kern (Das Schiff blitzt auf)
  // Wir setzen das Schiff und ein paar Nachbarn
  setPixel(0, playerY);
  setPixel(1, playerY);
  setPixel(0, playerY - 1);
  setPixel(0, playerY + 1);
  matrix.renderBitmap(frame, 8, 12);
  delay(150); // Kurz warten

  // Schritt 2: Kleiner Kreis (Ring 1)
  clearFrame();
  setPixel(0, playerY - 1); // Oben
  setPixel(0, playerY + 1); // Unten
  setPixel(2, playerY);     // Rechts
  setPixel(1, playerY - 1); // Diagonal
  setPixel(1, playerY + 1); // Diagonal
  matrix.renderBitmap(frame, 8, 12);
  delay(150);

  // Schritt 3: Mittlerer Kreis (Ring 2)
  clearFrame();
  // Ein paar Pixel, die einen Ring andeuten
  setPixel(0, playerY - 2);
  setPixel(0, playerY + 2);
  setPixel(3, playerY);
  setPixel(2, playerY - 1);
  setPixel(2, playerY + 1);
  setPixel(1, playerY - 2);
  setPixel(1, playerY + 2);
  matrix.renderBitmap(frame, 8, 12);
  delay(150);

  // Schritt 4: Großer Kreis & Trümmer fliegen (Ring 3)
  clearFrame();
  setPixel(0, playerY - 3);
  setPixel(0, playerY + 3);
  setPixel(5, playerY); // Fliegt weit nach rechts
  setPixel(3, playerY - 2);
  setPixel(3, playerY + 2);
  setPixel(2, playerY - 3);
  setPixel(2, playerY + 3);
  setPixel(4, playerY - 1);
  setPixel(4, playerY + 1);
  matrix.renderBitmap(frame, 8, 12);
  delay(200);

  // Schritt 5: Trümmer fliegen aus dem Bild
  clearFrame();
  // Nur noch ein paar weit entfernte Pixel
  setPixel(7, playerY); 
  setPixel(5, playerY - 2);
  setPixel(5, playerY + 2);
  setPixel(6, playerY - 1);
  setPixel(6, playerY + 1);
  setPixel(4, playerY - 3);
  setPixel(4, playerY + 3);
  matrix.renderBitmap(frame, 8, 12);
  delay(250);

  // Schritt 6: Letzter Blitz & Ausklingen
  clearFrame();
  setPixel(10, playerY);
  setPixel(8, playerY - 1);
  setPixel(8, playerY + 1);
  matrix.renderBitmap(frame, 8, 12);
  delay(300);

  // Letzte Pause um die 2 Sekunden zu füllen
  clearFrame();
  matrix.renderBitmap(frame, 8, 12);
  delay(650); 
  // Gesamtverzögerung ca.: 150+150+150+200+250+300+650 = 1850ms 
  // Der Rest kommt durch die Rechenzeit zustande.

  // Nach der Explosion in den Bereit-Zustand zurückkehren
  showReadyScreen();
}

void resetGame() {
  clearEnemies();
  gameSpeed = gameSpeedStart;
  gameOver = false;
  gameActive = true;
  moveCounter = 0;
  enc.clear();
  Serial.println("Neustart!");
}

void showReadyScreen() {
  // Nur das Raumschiff anzeigen, keine Gegner
  clearEnemies(); // Sicherstellen, dass keine Gegner da sind
  drawFrame();    // Zeichnet das Raumschiff an seiner aktuellen Position
  Serial.println("Bereit zum Start - Taster druecken!");
}

3 Der Arduino R4 WIFI Code für das SNAKE Spiel

#include "Arduino_LED_Matrix.h"
#include <K4_ENC.h>

// Hardware-Konfiguration
const int pinA = 2;
const int pinB = 3;
const int buttonPin = 4;

// Spiel-Parameter
const int width = 12;
const int height = 8;
const int maxSnakeLength = 64;

// Instanzen
K4_ENC snakeEnc; 
ArduinoLEDMatrix matrix; 

// Spiel-Variablen
int snakeX[maxSnakeLength];
int snakeY[maxSnakeLength];
int snakeLength = 3;
int foodX, foodY;
int dir = 0; // 0: Rechts, 1: Unten, 2: Links, 3: Oben
bool gameOver = false;
bool turnExecuted = false; // Verhindert 180-Grad-Wenden in einem Frame
unsigned long lastMoveTime = 0;
const int moveInterval = 250; 

// Matrix-Buffer
uint32_t frame[3] = {0, 0, 0};

void setPixel(int x, int y, bool state) {
  if (x < 0 || x >= width || y < 0 || y >= height) return;
  int bitPos = y * width + x;
  int wordIdx = bitPos / 32;
  int bitInWord = bitPos % 32;
  if (state) frame[wordIdx] |= (1UL << (31 - bitInWord));
  else frame[wordIdx] &= ~(1UL << (31 - bitInWord));
}

void spawnFood() {
  // Futter mit mindestens 2 Pixeln Abstand zum Rand
  // x: 2 bis 9 | y: 2 bis 5
  foodX = random(2, 10); 
  foodY = random(2, 6);  
}

void resetGame() {
  snakeLength = 3;
  int startX = 4;
  int startY = 3;
  for (int i = 0; i < snakeLength; i++) {
    snakeX[i] = startX - i;
    snakeY[i] = startY;
  }
  dir = 0;
  spawnFood();
  gameOver = false;
  turnExecuted = false;
  snakeEnc.clear(); 
}

void setup() {
  matrix.begin();
  snakeEnc.begin(); 
  randomSeed(analogRead(0));
  resetGame();
}

void loop() {
  snakeEnc.update();

  if (gameOver) {
    if (snakeEnc.isPressed()) {
      snakeEnc.clear();
      resetGame();
      delay(200);
    }
    return;
  }

  // Eingabe verarbeiten: Nur eine Drehung pro Bewegungsschritt zulassen
  int rotation = snakeEnc.getCount(); 
  if (rotation != 0 && !turnExecuted) {
    if (rotation > 0) {
      dir = (dir + 1) % 4; // Rechtskurve
    } else if (rotation < 0) {
      dir = (dir + 3) % 4; // Linkskurve
    }
    turnExecuted = true; // Sperre bis zum nächsten Schritt
    snakeEnc.clear(); 
  }

  // Zeitgesteuerte Bewegung
  if (millis() - lastMoveTime >= moveInterval) {
    lastMoveTime = millis();
    turnExecuted = false; // Drehung für den neuen Schritt wieder freigeben

    // Körper bewegen
    for (int i = snakeLength - 1; i > 0; i--) {
      snakeX[i] = snakeX[i - 1];
      snakeY[i] = snakeY[i - 1];
    }

    // Kopf bewegen
    if (dir == 0) snakeX[0]++;
    if (dir == 1) snakeY[0]++;
    if (dir == 2) snakeX[0]--;
    if (dir == 3) snakeY[0]--;

    // Präzise Kollisionsprüfung (0 bis 11 und 0 bis 7 sind gültig)
    if (snakeX[0] < 0 || snakeX[0] >= 12 || snakeY[0] < 0 || snakeY[0] >= 8) {
      gameOver = true;
    }

    // Selbst-Kollision (Kopf trifft Körper)
    for (int i = 1; i < snakeLength; i++) {
      if (snakeX[0] == snakeX[i] && snakeY[0] == snakeY[i]) {
        gameOver = true;
      }
    }

    // Futter-Logik
    if (snakeX[0] == foodX && snakeY[0] == foodY) {
      if (snakeLength < maxSnakeLength) snakeLength++;
      spawnFood();
    }

    // Zeichnen
    frame[0] = 0; frame[1] = 0; frame[2] = 0; 
    setPixel(foodX, foodY, true); 
    for (int i = 0; i < snakeLength; i++) {
      setPixel(snakeX[i], snakeY[i], true); 
    }
    matrix.loadFrame(frame);
  }
}

4 Der Arduino R4 WIFI Code für einen digitalen Würfel

#include "Arduino_LED_Matrix.h"
#include <K4_ENC.h>

// Hardware-Konfiguration (Default Pins 2, 3 und 4)
const int buttonPin = 4;

// Instanzen
K4_ENC myEncoder;
ArduinoLEDMatrix matrix;

// Matrix-Buffer für die 12x8 Anzeige
uint32_t frame[3] = {0, 0, 0};

// Funktion zum Setzen eines Pixels im Buffer
void setPixel(int x, int y, bool state) {
  if (x < 0 || x >= 12 || y < 0 || y >= 8) return;
  int bitPos = y * 12 + x;
  int wordIdx = bitPos / 32;
  int bitInWord = bitPos % 32;
  if (state) frame[wordIdx] |= (1UL << (31 - bitInWord));
  else frame[wordIdx] &= ~(1UL << (31 - bitInWord));
}

// Funktion zum Zeichnen der Würfelaugen (1-6)
void drawDice(int value) {
  // Buffer leeren
  frame[0] = 0; frame[1] = 0; frame[2] = 0;

  // Koordinaten für die Augen (mittig auf 12x8)
  // Links: x=3, Mitte: x=5, Rechts: x=7
  // Oben: y=1, Mitte: y=3, Unten: y=5

  // Punkt in der Mitte (für 1, 3, 5)
  if (value == 1 || value == 3 || value == 5) {
    setPixel(5, 3, true);
  }
  
  // Punkte oben-links und unten-rechts (für 2, 3, 4, 5, 6)
  if (value >= 2) {
    setPixel(3, 1, true);
    setPixel(7, 5, true);
  }
  
  // Punkte oben-rechts und unten-links (für 4, 5, 6)
  if (value >= 4) {
    setPixel(7, 1, true);
    setPixel(3, 5, true);
  }
  
  // Punkte in der Mitte links und rechts (nur für 6)
  if (value == 6) {
    setPixel(3, 3, true);
    setPixel(7, 3, true);
  }

  matrix.loadFrame(frame);
}

void setup() {
  matrix.begin();
  myEncoder.begin();
  
  // Zufallsgenerator initialisieren
  randomSeed(analogRead(0));

  // Start-Anzeige: Würfel mit der 1
  drawDice(1);
}

void loop() {
  // Hintergrund-Abfrage für den Encoder
  myEncoder.update();

  // Würfeln bei Tastendruck
  if (myEncoder.isPressed()) {
    myEncoder.clear();
    
    unsigned long startTime = millis();
    int lastRandom = 0;

    // 1500ms Animation
    while (millis() - startTime < 1500) {
      int currentRandom = random(1, 7);
      
      if (currentRandom != lastRandom) {
        drawDice(currentRandom);
        lastRandom = currentRandom;
      }
      delay(80); 
    }

    // Das endgültige Ergebnis
    int result = random(1, 7);
    drawDice(result);
  }
}

5 Der Arduino R4 WIFI Code für ein Lotto Spiel 6 aus 49 mit Superzahl

#include "Arduino_LED_Matrix.h"
#include <K4_ENC.h>

// Hardware-Konfiguration
const int pinA = 2;
const int pinB = 3;
const int buttonPin = 4;

// Instanzen
K4_ENC lottoEnc; // Pins 2, 3 und 4
ArduinoLEDMatrix matrix;

// Variablen
int gezogen[6];
uint32_t frame[3] = {0, 0, 0};

// Kompakte 3x5 Font für die Zahlen 0-9
const byte font[10][3] = {
  {0x1F, 0x11, 0x1F}, // 0
  {0x00, 0x1F, 0x00}, // 1
  {0x1D, 0x15, 0x17}, // 2
  {0x15, 0x15, 0x1F}, // 3
  {0x07, 0x04, 0x1F}, // 4
  {0x17, 0x15, 0x1D}, // 5
  {0x1F, 0x15, 0x1D}, // 6
  {0x01, 0x01, 0x1F}, // 7
  {0x1F, 0x15, 0x1F}, // 8
  {0x17, 0x15, 0x1F}  // 9
};

// Hilfsfunktion: Setzt einen Pixel im Buffer
void setPixel(int x, int y, bool state) {
  if (x < 0 || x >= 12 || y < 0 || y >= 8) return;
  int bitPos = y * 12 + x;
  int wordIdx = bitPos / 32;
  int bitInWord = bitPos % 32;
  if (state) frame[wordIdx] |= (1UL << (31 - bitInWord));
  else frame[wordIdx] &= ~(1UL << (31 - bitInWord));
}

// Löscht den aktuellen Buffer
void clearFrame() {
  frame[0] = 0; frame[1] = 0; frame[2] = 0;
}

// Zeichnet eine Ziffer an X-Position
void drawDigit(int n, int xOffset) {
  if (n < 0 || n > 9) return;
  for (int x = 0; x < 3; x++) {
    for (int y = 0; y < 5; y++) {
      if (font[n][x] & (1 << y)) {
        setPixel(x + xOffset, y + 1, true);
      }
    }
  }
}

// Zeigt die Zahl an
void displayZahl(int num) {
  clearFrame();
  if (num >= 10) {
    drawDigit(num / 10, 2);
    drawDigit(num % 10, 6);
  } else {
    drawDigit(num, 4);
  }
  matrix.loadFrame(frame);
}

//Rausch-Animation
void randomAnimation(int ms) {
  unsigned long start = millis();
  while (millis() - start < ms) {
    // Füllt den Buffer mit echtem 32-Bit Zufall
    for (int i = 0; i < 3; i++) {
      frame[i] = (uint32_t)random(0xFFFF) << 16 | random(0xFFFF);
    }
    matrix.loadFrame(frame);
    delay(40); // Etwas schneller für mehr Dynamik
  }
  clearFrame();
  matrix.loadFrame(frame); // Matrix kurz leeren vor der Zahl
}

void showHaken() {
  clearFrame();
  setPixel(3, 4, true); setPixel(4, 5, true); setPixel(5, 6, true);
  setPixel(6, 5, true); setPixel(7, 4, true); setPixel(8, 3, true); setPixel(9, 2, true);
  matrix.loadFrame(frame);
}

void setup() {
  Serial.begin(9600);
  matrix.begin();
  lottoEnc.begin();
  randomSeed(analogRead(0));
  showHaken();
  Serial.println("Lotto-System bereit!");
}

void loop() {
  lottoEnc.update();

  if (lottoEnc.isPressed()) {
    lottoEnc.clear();
    Serial.println("--- Starte Ziehung ---");

    for (int i = 0; i < 6; i++) {
      randomAnimation(1500); // 1,5 Sek Rauschen

      int neueZahl;
      bool doppelt;
      do {
        doppelt = false;
        neueZahl = random(1, 50);
        for (int j = 0; j < i; j++) {
          if (gezogen[j] == neueZahl) doppelt = true;
        }
      } while (doppelt);

      gezogen[i] = neueZahl;
      Serial.print("Zahl "); Serial.print(i + 1); Serial.print(": "); Serial.println(neueZahl);
      
      displayZahl(neueZahl);
      delay(1500); // Zahl 1,5 Sek anzeigen
    }

    // Superzahl
    Serial.println("Ziehe Superzahl...");
    randomAnimation(3000); // 3 Sek Rauschen
    
    int superZahl = random(0, 10);
    Serial.print("Superzahl: "); Serial.println(superZahl);
    
    displayZahl(superZahl);
    Serial.println("--- Ende ---");
  }
}

6 Der Arduino R4 WIFI Code für das Reaktionsspiel

#include "Arduino_LED_Matrix.h"
#include <K4_ENC.h>

// Hardware-Konfiguration
const int pinA = 2;
const int pinB = 3;
const int buttonPin = 4;

// Instanzen
K4_ENC reactionEnc; 
ArduinoLEDMatrix matrix;

// Der Totenkopf (12x8 exakt auf 3x32 Bit)
const uint32_t skull_frame[] = {
    0x1F83FC36, 
    0xC36C1F80, 
    0xF00F00A0
};

// Spielzustände: 1=Start, 2=Warten, 3=Flash/Messung, 4=Ergebnis
int gameState = 1;

unsigned long startTime;
unsigned long reactionTime;
unsigned long nextFlashTime;

void setup() {
  Serial.begin(9600);
  matrix.begin();
  reactionEnc.begin();
  
  pinMode(buttonPin, INPUT_PULLUP);
  
  randomSeed(analogRead(0));
  
  matrix.loadFrame(skull_frame);
  Serial.println("--- SPEED TEST ---");
  Serial.println("Druecke den Button zum Starten!");
}

void loop() {
  // Update
  if (gameState == 1 || gameState == 2 || gameState == 4) {
    reactionEnc.update();
  }

  // ZUSTAND 1: Startmenü 
  if (gameState == 1) {
    if (reactionEnc.isPressed()) {
      reactionEnc.clear();
      uint32_t off[] = {0, 0, 0};
      matrix.loadFrame(off);
      
      nextFlashTime = millis() + random(2000, 5000); 
      gameState = 2;
      Serial.println("Konzentration...");
    }
  }

  else if (gameState == 2) {
    if (reactionEnc.isPressed()) {
      reactionEnc.clear();
      Serial.println("FEHLSTART!");
      showX();
      delay(1500);
      matrix.loadFrame(skull_frame);
      gameState = 1;
    }
    else if (millis() >= nextFlashTime) {
      uint32_t flash[] = {0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};
      matrix.loadFrame(flash);
      
      // Zeitstempel SOFORT nehmen
      startTime = millis();
      gameState = 3;
    }
  }

  // ZUSTAND 3: DIE MESSUNG 
  else if (gameState == 3) {
    if (digitalRead(buttonPin) == LOW) {
      reactionTime = millis() - startTime;
      
      uint32_t off[] = {0, 0, 0};
      matrix.loadFrame(off);
      
      Serial.print("REAKTION: ");
      Serial.print(reactionTime);
      Serial.println(" ms");
      reactionEnc.clear(); 
      gameState = 4;
    }
  }

  // ZUSTAND 4: Auswertung
  else if (gameState == 4) {
    if (reactionTime < 250) showFast();
    else showSlow();
    
    delay(2500); // Pause nach dem Spiel
    matrix.loadFrame(skull_frame);
    gameState = 1;
  }
}

// Symbole
void showX() {
  uint32_t x_frame[] = {0x80244428, 0x1100110, 0x28444208};
  matrix.loadFrame(x_frame);
}

void showFast() {
  uint32_t blitz[] = {0x000600C0, 0x01800300, 0x06000C00};
  matrix.loadFrame(blitz);
}

void showSlow() {
  uint32_t dot[] = {0x0, 0x01800180, 0x0};
  matrix.loadFrame(dot);
}

7 Der Arduino R4 WIFI Code für das Metronom

#include "Arduino_LED_Matrix.h"

// Hardware-Pins
const int pinA = 2;       // Encoder Phase A
const int pinB = 3;       // Encoder Phase B
const int buttonPin = 4;  // Start/Stop Taster

// Instanz für die LED-Matrix
ArduinoLEDMatrix matrix;

// Variablen für das Metronom
int bpm = 120;
const int minBpm = 40;
const int maxBpm = 240;
bool isRunning = false;
unsigned long lastBeatTime = 0;
bool noteVisible = false;

// Variablen für den Encoder
int lastStateA;
unsigned long lastButtonPress = 0;

// Frame für die stilisierte Note (12x8 Matrix)
const uint32_t note_frame[] = {
  0x03003003, // Obere Segmente (Fahne und Hals)
  0x00300300, // Mittlere Segmente (Hals)
  0x3e07f03e  // Untere Segmente (Notenkopf)
};

// Leeres Frame zum Ausschalten
const uint32_t empty_frame[] = {
  0, 0, 0
};

void setup() {
  Serial.begin(9600);
  
  // Matrix initialisieren
  matrix.begin();
  
  // Pins konfigurieren
  pinMode(pinA, INPUT_PULLUP);
  pinMode(pinB, INPUT_PULLUP);
  pinMode(buttonPin, INPUT_PULLUP);
  
  // Startzustand Encoder
  lastStateA = digitalRead(pinA);
  
  Serial.println("Metronom bereit.");
  Serial.print("Aktuelles Tempo: ");
  Serial.print(bpm);
  Serial.println(" BPM");
}

void loop() {
  handleEncoder();
  handleButton();
  handleMetronome();
}

void handleEncoder() {
  int currentStateA = digitalRead(pinA);
  
  // Einfache Encoder-Logik zur BPM-Steuerung
  if (currentStateA != lastStateA && currentStateA == LOW) {
    if (digitalRead(pinB) != currentStateA) {
      bpm = min(bpm + 1, maxBpm);
    } else {
      bpm = max(bpm - 1, minBpm);
    }
    Serial.print("Tempo: ");
    Serial.print(bpm);
    Serial.println(" BPM");
  }
  lastStateA = currentStateA;
}

void handleButton() {
  // Entprellen des Start/Stop-Tasters
  if (digitalRead(buttonPin) == LOW) {
    if (millis() - lastButtonPress > 250) {
      isRunning = !isRunning;
      lastButtonPress = millis();
      
      if (isRunning) {
        Serial.println("Metronom gestartet.");
      } else {
        Serial.println("Metronom gestoppt.");
        matrix.loadFrame(empty_frame);
      }
    }
  }
}

void handleMetronome() {
  if (!isRunning) return;

  unsigned long currentMillis = millis();
  unsigned long beatInterval = 60000 / bpm; // Berechnung des Intervalls in ms

  // Takt-Logik
  if (currentMillis - lastBeatTime >= beatInterval) {
    lastBeatTime = currentMillis;
    
    // Note anzeigen
    matrix.loadFrame(note_frame);
    noteVisible = true;
  }
  
  // Note nach einer kurzen Dauer (100ms) wieder ausblenden
  if (noteVisible && (currentMillis - lastBeatTime > 100)) {
    matrix.loadFrame(empty_frame);
    noteVisible = false;
  }
}

8 Der Arduino R4 WIFICode für den "Klick" Zähler

#include "Arduino_LED_Matrix.h"
#include <K4_ENC.h>

// Hardware-Setup
const int buttonPin = 4;
K4_ENC myCounter; // Pins 2, 3 und 4
ArduinoLEDMatrix matrix;

// Variablen
int totalCount = 0;
uint32_t frame[3] = {0, 0, 0};

// Kompakte 3x5 Font für die Zahlen 0-9
const byte font[10][3] = {
  {0x1F, 0x11, 0x1F}, // 0
  {0x00, 0x1F, 0x00}, // 1
  {0x1D, 0x15, 0x17}, // 2
  {0x15, 0x15, 0x1F}, // 3
  {0x07, 0x04, 0x1F}, // 4
  {0x17, 0x15, 0x1D}, // 5
  {0x1F, 0x15, 0x1D}, // 6
  {0x01, 0x01, 0x1F}, // 7
  {0x1F, 0x15, 0x1F}, // 8
  {0x17, 0x15, 0x1F}  // 9
};

void setPixel(int x, int y, bool state) {
  if (x < 0 || x >= 12 || y < 0 || y >= 8) return;
  int bitPos = y * 12 + x;
  int wordIdx = bitPos / 32;
  int bitInWord = bitPos % 32;
  if (state) frame[wordIdx] |= (1UL << (31 - bitInWord));
  else frame[wordIdx] &= ~(1UL << (31 - bitInWord));
}

void drawDigit(int n, int xOffset) {
  if (n < 0 || n > 9) return;
  for (int x = 0; x < 3; x++) {
    for (int y = 0; y < 5; y++) {
      if (font[n][x] & (1 << y)) {
        setPixel(x + xOffset, y + 1, true);
      }
    }
  }
}

void updateDisplay() {
  frame[0] = 0; frame[1] = 0; frame[2] = 0;
  
  // Unterstützung für Zahlen von -9 bis 99 auf der kleinen Matrix
  if (totalCount >= 0 && totalCount < 10) {
    drawDigit(totalCount, 4); // Einstellige Zahl mittig
  } else if (totalCount >= 10 && totalCount <= 99) {
    drawDigit(totalCount / 10, 2); // Zehnerstelle
    drawDigit(totalCount % 10, 6); // Einerstelle
  } else if (totalCount < 0 && totalCount > -10) {
    // Minuszeichen bei negativen Zahlen (sehr simpel)
    setPixel(2, 3, true); setPixel(3, 3, true);
    drawDigit(abs(totalCount), 6);
  } else {
    // Überlauf-Anzeige (X), wenn Zahl zu groß für das Display ist
    setPixel(4, 2, true); setPixel(7, 2, true);
    setPixel(5, 3, true); setPixel(6, 3, true);
    setPixel(5, 4, true); setPixel(6, 4, true);
    setPixel(4, 5, true); setPixel(7, 5, true);
  }
  
  matrix.loadFrame(frame);
}

void setup() {
  Serial.begin(9600);
  matrix.begin();
  myCounter.begin();
  
  updateDisplay();
  Serial.println("Klick-Zaehler bereit!");
}

void loop() {
  // Hintergrund-Verarbeitung für Entprellung
  myCounter.update();
  delay(20);

  // 1. Zählen durch Drehen
  int rotation = myCounter.getCount();
  if (rotation != 0) {
    totalCount += rotation;
    myCounter.clear(); // Zählerstand nach Übernahme nullen
    
    updateDisplay();
    Serial.print("Zaehlerstand: ");
    Serial.println(totalCount);
  }

  // 2. Reset durch Button-Druck
  if (myCounter.isPressed()) {
    totalCount = 0;
    myCounter.clear();
    
    updateDisplay();
    Serial.println("Zaehler auf 0 zurueckgesetzt.");
    
    // Kurze Pause, um Mehrfach-Reset zu vermeiden
    delay(300);
  }
}

9 Der Arduino R4 WIFI Code für die Stoppuhr bis 999 Sekunden

#include "Arduino_LED_Matrix.h"
#include <K4_ENC.h>

// Hardware-Setup
K4_ENC stopWatchEnc; // Nutzt Default-Pins 2, 3 und 4
ArduinoLEDMatrix matrix;

// Variablen für die Zeitmessung
unsigned long startTime = 0;
unsigned long elapsedTime = 0;
unsigned long lastSerialUpdate = 0;
bool running = false;

uint32_t frame[3] = {0, 0, 0};

// Extra schmale 3x5 Font für 3 Stellen auf 12 Pixeln
const byte smallFont[10][3] = {
  {0x1F, 0x11, 0x1F}, // 0
  {0x00, 0x1F, 0x00}, // 1
  {0x1D, 0x15, 0x17}, // 2
  {0x15, 0x15, 0x1F}, // 3
  {0x07, 0x04, 0x1F}, // 4
  {0x17, 0x15, 0x1D}, // 5
  {0x1F, 0x15, 0x1D}, // 6
  {0x01, 0x01, 0x1F}, // 7
  {0x1F, 0x15, 0x1F}, // 8
  {0x17, 0x15, 0x1F}  // 9
};

void setPixel(int x, int y, bool state) {
  if (x < 0 || x >= 12 || y < 0 || y >= 8) return;
  int bitPos = y * 12 + x;
  int wordIdx = bitPos / 32;
  int bitInWord = bitPos % 32;
  if (state) frame[wordIdx] |= (1UL << (31 - bitInWord));
  else frame[wordIdx] &= ~(1UL << (31 - bitInWord));
}

void drawDigit(int n, int xOffset) {
  if (n < 0 || n > 9) return;
  for (int x = 0; x < 3; x++) {
    for (int y = 0; y < 5; y++) {
      if (smallFont[n][x] & (1 << y)) {
        setPixel(x + xOffset, y + 1, true);
      }
    }
  }
}

void updateDisplay(int seconds) {
  frame[0] = 0; frame[1] = 0; frame[2] = 0;
  
  if (seconds > 999) seconds = 999; // Deckelung bei 3 Stellen

  int h = seconds / 100;         // Hunderter
  int z = (seconds / 10) % 10;   // Zehner
  int e = seconds % 10;          // Einer

  // Wir zeichnen immer alle drei Stellen für die Symmetrie
  drawDigit(h, 0); // Position 0,1,2
  drawDigit(z, 4); // Position 4,5,6
  drawDigit(e, 8); // Position 8,9,10
  
  matrix.loadFrame(frame);
}

void setup() {
  Serial.begin(9600);
  matrix.begin();
  stopWatchEnc.begin();
  
  updateDisplay(0);
  Serial.println("Stoppuhr bereit! Druecke den Button zum Starten.");
}

void loop() {
  stopWatchEnc.update();

  // Button-Logik: Start -> Stopp -> Reset
  if (stopWatchEnc.isPressed()) {
    stopWatchEnc.clear();
    
    if (!running && elapsedTime == 0) {
      // START
      startTime = millis();
      running = true;
      Serial.println("Zeitmessung laeuft...");
    } 
    else if (running) {
      // STOPP
      elapsedTime += millis() - startTime;
      running = false;
      Serial.println("Gestoppt.");
    } 
    else {
      // RESET
      elapsedTime = 0;
      updateDisplay(0);
      Serial.println("Reset auf 0.");
    }
    delay(200); // Entprellen
  }

  // Wenn sie läuft, Zeit berechnen
  unsigned long currentElapsed = elapsedTime;
  if (running) {
    currentElapsed += millis() - startTime;
  }

  // Display-Update (nur volle Sekunden)
  static int lastSec = -1;
  int displaySec = currentElapsed / 1000;
  if (displaySec != lastSec) {
    updateDisplay(displaySec);
    lastSec = displaySec;
  }

  // Serial Monitor Update (Sekunden und Zehntel)
  if (running && (millis() - lastSerialUpdate >= 100)) {
    lastSerialUpdate = millis();
    float finalTime = currentElapsed / 1000.0;
    Serial.print("Zeit: ");
    Serial.print(finalTime, 1); // Eine Nachkommastelle (Zehntel)
    Serial.println(" s");
  }
}

10 Der Arduino R4 WIFI Code für die Matrix Simulation

#include "Arduino_LED_Matrix.h"

// Hardware-Setup
ArduinoLEDMatrix matrix;

// Einstellungen für den Regen
const int numCols = 12;
const int numRows = 8;
const int maxTail = 4; // Länge des Pixelschweifs

// Variablen für die Animation
int yPos[numCols];       // Aktuelle Y-Position des "Kopfes" pro Spalte
int speeds[numCols];     // Individuelle Geschwindigkeit
int counters[numCols];   // Zähler für das Timing

uint32_t frame[3] = {0, 0, 0};

// Hilfsfunktion: Setzt einen Pixel im Buffer
void setPixel(int x, int y, bool state) {
  if (x < 0 || x >= 12 || y < 0 || y >= 8) return;
  int bitPos = y * 12 + x;
  int wordIdx = bitPos / 32;
  int bitInWord = bitPos % 32;
  if (state) frame[wordIdx] |= (1UL << (31 - bitInWord));
  else frame[wordIdx] &= ~(1UL << (31 - bitInWord));
}

void setup() {
  matrix.begin();
  
  // Zufallsgenerator für unterschiedliche Startpunkte
  randomSeed(analogRead(0));

  // Jede Spalte bekommt einen zufälligen Startpunkt oberhalb des Displays
  for (int i = 0; i < numCols; i++) {
    yPos[i] = random(-15, 0); 
    speeds[i] = random(2, 6);  // Zufälliges Tempo (kleiner = schneller)
    counters[i] = 0;
  }
}

void loop() {
  // Buffer für das neue Bild komplett leeren
  frame[0] = 0; frame[1] = 0; frame[2] = 0;

  for (int i = 0; i < numCols; i++) {
    // Individuelles Tempo der Spalte verarbeiten
    counters[i]++;
    if (counters[i] >= speeds[i]) {
      counters[i] = 0;
      yPos[i]++;
      
      // Wenn der Regen-Tropfen mitsamt Schweif unten raus ist, oben neu starten
      if (yPos[i] > numRows + maxTail) { 
        yPos[i] = random(-5, 0);
        speeds[i] = random(2, 6);
      }
    }

    // Den "Regentropfen" zeichnen (Kopf + Schweif nach oben)
    for (int j = 0; j < maxTail; j++) {
      // Nur Pixel zeichnen, die tatsächlich auf dem 8-Zeilen-Display liegen
      setPixel(i, yPos[i] - j, true);
    }
  }

  // Das fertige Frame auf die Matrix schieben
  matrix.loadFrame(frame);
  
  // Kurze Pause für die Grund-Framerate
  delay(30);
}

10 weitere "Out of the Box" Ideen (WLAN & Besonderes)

Bitcoin/Aktien-Ticker: Holt den aktuellen Kurs via API und lässt ihn als Lauftext durchlaufen.
YouTube-Subscriber Counter: Live-Anzeige deiner (oder fremder) Abonnentenzahlen.
WLAN-Scanner: Zeigt die Anzahl der verfügbaren Netzwerke in der Umgebung an.
Remote-Pixel-Chat: Eine simple Weboberfläche, mit der Freunde über das Internet Bilder auf deine Matrix malen können.
Wetter-Vorhersage: Zeigt Symbole für Sonne, Regen oder Wolken basierend auf Online-Daten.
Twitch-Alert: Die Matrix blinkt auf, wenn ein bestimmter Streamer online geht.
MQTT-Dashboard: Zeigt Statusmeldungen von deinem Smart Home (z.B. "Fenster OFFEN").
Game of Life: Conways berühmte Simulation läuft autonom auf der Matrix ab.
E-Mail Notifier: Ein Briefumschlag-Symbol erscheint, wenn eine neue Mail im Posteingang landet.
Web-Radio Status: Wenn der R4 als Streamer fungiert, wird der aktuelle Songtitel gescrollt.

Ronnie

schwäbischer tüftler und bastler, kraftsportler, neurodivers, 45 Jahre, 1 Frau, 5 Kinder und 1003 Ideen.