Details: Kategorie: Arduino neue Ideen; Erstellt: 02. April 2026; Zugriffe: 13

Dieses Board ist eine tolle All-in-One-Lösung für den Arduino. Statt einfacher Segmente hast du eine vollgrafische LED-Matrix für Texte und Animationen sowie NeoPixel für Millionen von Farben. Durch den Joystick und den Encoder lassen sich komplexe Menüs und Spiele realisieren, während Sensoren für Ton, Bewegung, Distanz und Temperatur die Brücke zur Umwelt schlagen.

Die Anschlüsse deines Boards

Komponente	Pins	Beschreibung
I2C LED Matrix	SDA / SCL	16x8 Pixel für Text & Grafik
Batterie-Anzeige	D10 (CLK), D11 (DIO)	10-Segment Bar-Graph Display
Rotary Encoder	D2 (SA), D3 (SB), D4 (SW)	Drehregler mit Klick-Funktion
DS18B20	D5	Digitaler Präzisions-Temperatursensor
PIR Sensor	D6	Passiv-Infrarot Bewegungsmelder
Ultraschall (HC-SR04)	D7, D8	Header für Distanzmessung (Trigger/Echo)
2-Achsen Joystick	A0 (X), A1 (Y)	Analoger Stick für Steuerung
Mikrofon	A2	Schallsensor für Lautstärkemessung
NEO Pixel LEDs	A3	4 adressierbare RGB-LEDs (WS2812B)

40 Neue Projektideen für dein Board

🏠 Alltag & Lifestyle

Hardware Check: Teste alle Funktionen des rich shield 2.
Klatsch-Schalter: Ein lautes Klatschen (Mikrofon) schaltet die NeoPixel als sanftes Nachtlicht ein.
Abstands-Parkhilfe:
1. Die NeoPixel wechseln von Grün nach Rot, je näher ein Objekt dem Ultraschallsensor kommt.
2. Zusätlich zu den LEDs wird der Abstand in cm. auf dem Display angeziegt
3. Auf der 128 Pixel LED Anzeige, wird der Abstand als Balkan angezeigt
Stimmungs-Barometer: Nutze den Inkrementalgeber, um die Farbe aller 4 NeoPixel stufenlos zu mischen.
Digitales Thermometer: Zeige die exakte Temperatur des DS18B20 groß auf der LED-Matrix an.
Lautstärke-Wächter: Die Batterie-Anzeige (Bar-Graph) visualisiert den Geräuschpegel im Raum.
Eieruhr mit Fortschritt: Der Encoder stellt die Zeit ein, die Batterie-Anzeige zeigt den Zeitablauf als schrumpfenden Balken.
Bewegungs-Alarm: Wenn der PIR auslöst, blitzen die NeoPixel rot/blau wie ein Warnlicht.
Lüftungs-Check: Misst die Temperatur; bei drastischen Änderungen (Fenster auf) blinkt ein NeoPixel blau.
Welcome-Schild: Der PIR erkennt dich an der Tür und die Matrix lässt einen Begrüßungstext durchlaufen.

🎮 Spiele & Unterhaltung

Space-Invader: Steuere dein Raumschiff mit dem Joystick gegen die Feinde in die Schlacht, schieße so lange du du noch kannst.
Flappy Pixel: Springe mit dem Encoder-Button durch Lücken in den Hindernissen auf der Matrix.
Snake: Der Klassiker, perfekt steuerbar mit dem 2-Achsen Joystick.
Audio-Visualizer: Die Matrix zeigt tanzende Balken passend zur Musik in deiner Umgebung (Mikrofon).
Reaktions-Trainer: Wenn die NeoPixel die Farbe wechseln, musst du so schnell wie möglich den Joystick in eine Richtung drücken.
Tresorknacker: Finde den richtigen Drehwinkel am Encoder; die NeoPixel zeigen an, ob du "heiß" oder "kalt" bist.
Zufalls-Farbrad: Drehe den Encoder schnell; beim Stoppen leuchtet ein NeoPixel in einer Zufallsfarbe.
Schreiduell: Wer kann das Mikrofon am lautesten aktivieren? Die Batterie-Anzeige speichert den Spitzenwert.
Pixel-Art Designer: Nutze den Joystick als Cursor, um einzelne Pixel auf der Matrix ein- oder auszuschalten.
Labyrinth-Spiel: Navigiere einen Punkt mit dem Joystick durch ein statisches Hindernis-Feld auf der Matrix.

🛠️ Werkzeuge & Gadgets

Ultraschall-Maßband: Zeige die Distanz in Zentimetern direkt auf der Matrix an.
Wasserwaage (Simuliert): Nutze den Joystick, um ein "Gleichgewicht" auf der Matrix zu halten.
RGB-Hex-Generator: Mische eine Farbe mit dem Joystick und lass dir den HEX-Code für Webdesign auf der Matrix anzeigen.
Sound-Level-Meter: Kalibriertes Messgerät für die Lautstärke, Anzeige über den Bar-Graph.
Encoder-Menü-Template: Ein professionelles Menü-System auf der Matrix, durch das du mit dem Encoder scrollst.
DS18B20 Datenlogger: Zeige den Temperaturverlauf der letzten Minuten als kleinen Graph auf der Matrix.
Binär-Uhr: Nutze die 8 Zeilen der Matrix, um die Uhrzeit im Binärformat darzustellen.
Puls-Generator: Der Encoder stellt eine Frequenz ein, die NeoPixel blinken exakt in diesem Takt.
Batterie-Tester (Simulator): Nutze den A3 Pin (falls frei verfügbar), um Spannungen auf dem Bar-Graph anzuzeigen.
Morse-Trainer: Gib Morsezeichen über den Joystick ein; die Matrix übersetzt sie in Buchstaben.

⚙️ MINT-Projektideen

Schallgeschwindigkeits-Rechner: Berechne den Abstand mit dem Ultraschall und lerne die Formel dahinter.
Thermische Trägheit: Beobachte, wie langsam der DS18B20 auf Wärme reagiert und stelle die Kurve auf der Matrix dar.
Geräusch-Statistik: Zähle über 10 Sekunden alle Schallspitzen und berechne den Durchschnitt.
Lichtgeschwindigkeit-Analogie: Nutze die Matrix-Animationen, um zu erklären, wie Frames und Bildwiederholraten funktionieren.
Bit-Manipulation: Lerne, wie man einzelne Pixel einer 16x8 Matrix über Byte-Arrays ansteuert.
PID-Regler-Demo: Versuche, den Ultraschall-Abstand durch Handbewegung konstant zu halten (visuelles Feedback über NeoPixel).
Frequenz-Analyse: Visualisiere verschiedene Töne (Pfeifen vs. Klopfen) auf dem Bar-Graph.
Mapping-Kurs: Lerne, wie man den Analogwert des Joysticks (0-1023) auf die Matrix (0-15) umrechnet.
Logik-Simulation: Nutze den Joystick als Eingabe für Gatter (Links=A, Rechts=B) und die Matrix für das Ergebnis.
Wärmeleitungs-Experiment: Erhitze (vorsichtig!) ein Metallstück am DS18B20 und miss den Temperaturanstieg pro Sekunde.

1. Der Hardware-Check

Damit du genau weißt, wie du dein Open Smart Rich Shield Two mit dem Testcode prüfst, habe ich dir hier den Ablauf strukturiert zusammengefasst. Folge einfach den Anweisungen im Seriellen Monitor (9600 Baud), um jedes Bauteil einmal "wachzurütteln".

Vorbereitung: Installiere die nötigen Bibliotheken (NeoPixel, DallasTemperature, Matrix, TM1651) und öffne den Seriellen Monitor.
Encoder-Initialisierung: Drehe den Knopf nach rechts bis zum Wert 10 und dann wieder zurück auf 0. Das schließt den ersten Test ab und dient als Bestätigung für die Steuerung.
Weiter immer mit dem Taster vom Encoder.
Matrix-Flächentest: Die 16x8 LED-Matrix leuchtet komplett auf. Prüfe, ob alle Pixel aktiv sind, und bestätige durch eine Rechtsdrehung am Encoder.
Sound-Check: Klatsche in die Hände. Der Arduino zeigt dir den Ausschlag des Mikrofons an. Drehe nach rechts, wenn du zufrieden bist.
NeoPixel-Farbmix: Die vier RGB-LEDs wechseln durch Rot, Grün und Blau. Schau nach, ob alle Farben sauber dargestellt werden.
Bar-Graph-Lauflicht: Die 10-Segment-Ladeanzeige füllt sich schnell und leert sich wieder – ideal, um die Segmente auf Fehler zu prüfen.
Präzisions-Temperatur: Der DS18B20 misst die Raumtemperatur. Kontrolliere im Monitor, ob der Wert realistisch erscheint.
PIR-Bewegungsmelder: Halte deine Hand über den Sensor. Der Monitor meldet dir sofort den Wechsel zwischen "EIN" und "AUS".
Joystick-Quadranten: Bewege den Stick in alle Richtungen. Du siehst die analogen Werte für die X- und Y-Achse, die sich zwischen 0 und 1023 bewegen sollten.
Ultraschall-Option: Wähle per Linksdrehung (Nein) oder Rechtsdrehung (Ja), ob du einen HC-SR04 eingesteckt hast. Falls ja, halte ein Blatt Papier davor und beobachte die Distanzwerte.
Abschluss-Animation: Sobald alles erledigt ist, erscheint ein Smiley auf der Matrix und der erste NeoPixel pulsiert sanft in Rot. Dein Board ist nun offiziell "einsatzbereit".

Der Hardware Check für das Arduino rich shield 2

// www.kreativekiste.de // 03.04.2026 // Version 2.3

#include <OneWire.h>
#include <DallasTemperature.h>
#include <Adafruit_NeoPixel.h>
#include <TM1651.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_LEDBackpack.h>

// Pin Definitionen
#define PIN_ENC_SA 2
#define PIN_ENC_SB 3
#define PIN_ENC_SW 4
#define PIN_TEMP 5
#define PIN_PIR 6
#define PIN_US_TRIG 7
#define PIN_US_ECHO 8
#define PIN_BAT_CLK 10
#define PIN_BAT_DIO 11
#define PIN_JOY_X A0
#define PIN_JOY_Y A1
#define PIN_MIC A2
#define PIN_NEO A3

#define NUM_PIXELS 4 

// Hardware Objekte
OneWire oneWire(PIN_TEMP);
DallasTemperature sensors(&oneWire);
Adafruit_NeoPixel pixels(NUM_PIXELS, PIN_NEO, NEO_GRB + NEO_KHZ800);
TM1651 batteryDisplay(PIN_BAT_CLK, PIN_BAT_DIO);
Adafruit_8x16minimatrix matrix = Adafruit_8x16minimatrix();

// Variablen für den Ablauf
int encoderPos = 0;
int lastSA;
int initialButtonState;
int testSchritt = 1; 
unsigned long lastSerialTime = 0;
int ledFarbe = 0; 

void setup() {
  Serial.begin(9600);
  
  pinMode(PIN_ENC_SA, INPUT);
  pinMode(PIN_ENC_SB, INPUT);
  pinMode(PIN_ENC_SW, INPUT_PULLUP);
  pinMode(PIN_PIR, INPUT);
  pinMode(PIN_US_TRIG, OUTPUT);
  pinMode(PIN_US_ECHO, INPUT);

  sensors.begin();
  
  pixels.begin();
  pixels.setBrightness(30); 
  pixels.clear();
  pixels.show();

  batteryDisplay.init();
  batteryDisplay.set(BRIGHT_TYPICAL);
  batteryDisplay.displayLevel(0);

  // Matrix initialisieren
  matrix.begin(0x70); 
  matrix.setRotation(1); // Dreht das Display, damit 16 Pixel in der Breite liegen
  matrix.clear();
  matrix.writeDisplay();

  Serial.println("--- Hardwaretest Rich Shield 2 ---");
  Serial.println("Immer wenn du einen Wert siehst und er plausibel ist, druecke den Encoder Taster.");
  Serial.println("-------------------------------------------------------------------------");
  
  delay(200); 
  lastSA = digitalRead(PIN_ENC_SA);
  initialButtonState = digitalRead(PIN_ENC_SW);
  
  Serial.print("Initialzustand PIN 4: ");
  Serial.println(initialButtonState == HIGH ? "HIGH" : "LOW");
  Serial.println("\nTest 1: Drehe nun am Encoder (hoch/runter).");
}

void loop() {
  // --- TASTERABFRAGE FÜR WEITERSCHALTEN ---
  int currentButtonState = digitalRead(PIN_ENC_SW);
  if (currentButtonState != initialButtonState) {
    delay(100); 
    if (digitalRead(PIN_ENC_SW) == currentButtonState) {
      
      testSchritt++; 
      
      Serial.println("\n--------------------------------------------------");
      Serial.println("Tasterdruck erkannt! Wechsle zum naechsten Test.");
      Serial.println("--------------------------------------------------");

      // Vorherige Hardware ausschalten
      pixels.clear();
      pixels.show();
      batteryDisplay.displayLevel(0);
      matrix.clear();
      matrix.writeDisplay();

      while (digitalRead(PIN_ENC_SW) != initialButtonState) {
        delay(10);
      }

      // Ankündigung für den neuen Test
      if (testSchritt == 2) Serial.println("Test 2: Bewege den Joystick (X und Y Achse).");
      else if (testSchritt == 3) Serial.println("Test 3: Mikrofon-Test. Mache ein Geraeusch.");
      else if (testSchritt == 4) Serial.println("Test 4: Temperatur-Sensor (DS18B20).");
      else if (testSchritt == 5) Serial.println("Test 5: PIR Bewegungsmelder.");
      else if (testSchritt == 6) Serial.println("Test 6: NeoPixel RGB Blink-Test (30 Helligkeit, 500ms).");
      else if (testSchritt == 7) Serial.println("Test 7: Batterieanzeige Animation (500ms).");
      else if (testSchritt == 8) Serial.println("Test 8: Ultraschallsensor. Halte etwas vor den Sensor.");
      else if (testSchritt == 9) {
        Serial.println("**************************************************");
        Serial.println("TEST abgeschlossen");
        Serial.println("**************************************************");
        
        matrix.clear();
        // Smiley links (Koordinaten angepasst für Rotation)
        matrix.drawPixel(2, 1, LED_ON); matrix.drawPixel(5, 1, LED_ON); // Augen
        matrix.drawPixel(1, 4, LED_ON); matrix.drawPixel(2, 5, LED_ON); // Mund
        matrix.drawPixel(3, 5, LED_ON); matrix.drawPixel(4, 5, LED_ON);
        matrix.drawPixel(5, 5, LED_ON); matrix.drawPixel(6, 4, LED_ON);
        
        // Haken rechts (X von 8 bis 15)
        matrix.drawLine(10, 4, 12, 6, LED_ON); 
        matrix.drawLine(12, 6, 15, 1, LED_ON); 
        
        matrix.writeDisplay();
      }
    }
  }

  // --- DIE EINZELNEN TESTS ---
  
  if (testSchritt == 1) {
    int sa = digitalRead(PIN_ENC_SA);
    if (sa != lastSA && sa == HIGH) {
      if (digitalRead(PIN_ENC_SB) != sa) encoderPos++; else encoderPos--;
      Serial.print("Encoder Wert: "); Serial.println(encoderPos);
    }
    lastSA = sa;
  } 
  else if (testSchritt == 2) {
    if (millis() - lastSerialTime > 300) {
      Serial.print("Joystick X: "); Serial.print(analogRead(PIN_JOY_X));
      Serial.print(" | Y: "); Serial.println(analogRead(PIN_JOY_Y));
      lastSerialTime = millis();
    }
  }
  else if (testSchritt == 3) {
    if (millis() - lastSerialTime > 200) {
      Serial.print("Mikrofon Pegel: "); Serial.println(analogRead(PIN_MIC));
      lastSerialTime = millis();
    }
  }
  else if (testSchritt == 4) {
    if (millis() - lastSerialTime > 800) {
      sensors.requestTemperatures(); 
      float tempC = sensors.getTempCByIndex(0);
      Serial.print("Temperatur: "); Serial.print(tempC); Serial.println(" Grad Celsius");
      lastSerialTime = millis();
    }
  }
  else if (testSchritt == 5) {
    if (millis() - lastSerialTime > 400) {
      Serial.print("PIR Status: ");
      Serial.println(digitalRead(PIN_PIR) == HIGH ? "BEWEGUNG (ON)" : "Ruhig (OFF)");
      lastSerialTime = millis();
    }
  }
  else if (testSchritt == 6) {
    if (millis() - lastSerialTime > 500) {
      pixels.clear();
      if (ledFarbe == 0) {
        for(int i=0; i<NUM_PIXELS; i++) pixels.setPixelColor(i, pixels.Color(255, 0, 0));
        ledFarbe = 1;
      } else if (ledFarbe == 1) {
        for(int i=0; i<NUM_PIXELS; i++) pixels.setPixelColor(i, pixels.Color(0, 255, 0));
        ledFarbe = 2;
      } else {
        for(int i=0; i<NUM_PIXELS; i++) pixels.setPixelColor(i, pixels.Color(0, 0, 255));
        ledFarbe = 0;
      }
      pixels.show();
      lastSerialTime = millis();
    }
  }
  else if (testSchritt == 7) {
    static int batLevel = 0;
    static bool hochzaehlen = true;
    if (millis() - lastSerialTime > 500) {
      batteryDisplay.displayLevel(batLevel);
      if (hochzaehlen) { batLevel++; if (batLevel >= 7) hochzaehlen = false; }
      else { batLevel--; if (batLevel <= 0) hochzaehlen = true; }
      lastSerialTime = millis();
    }
  }
  else if (testSchritt == 8) {
    if (millis() - lastSerialTime > 500) {
      digitalWrite(PIN_US_TRIG, LOW); delayMicroseconds(2);
      digitalWrite(PIN_US_TRIG, HIGH); delayMicroseconds(10);
      digitalWrite(PIN_US_TRIG, LOW);
      long duration = pulseIn(PIN_US_ECHO, HIGH);
      long distance = (duration / 2) / 29.1;
      Serial.print("Entfernung: "); Serial.print(distance); Serial.println(" cm");
      lastSerialTime = millis();
    }
  }
}

2. Das Klatsch-Nachtlicht mit „Atem-Effekt“

Das Herzstück dieses Projekts ist das verbaute Mikrofon, das permanent die Umgebungsgeräusche scannt. Sobald du in die Hände klatschst, erkennt der Arduino den Pegelausschlag und schaltet die vier NeoPixel ein. Das Besondere: Wir nutzen rotes Licht, da dieses die Nachtsicht deiner Augen am wenigsten stört.

Der „Atmen-Effekt“: Pure Entspannung

Ein normales Licht, das einfach nur starr leuchtet, ist langweilig. Deshalb verpassen wir unserem Nachtlicht einen „Breathing-Effekt“. Die LEDs werden ganz langsam heller und dunkler – fast so, als würde das Licht ruhig atmen. Das wirkt extrem beruhigend und ist ideal zum Einschlafen.

Damit dieses Leuchten absolut flüssig wirkt, nutzen wir ein wenig Mathematik. Wir steuern die Helligkeit über eine Sinus-Kurve. Damit das Licht nie ganz ausgeht und dich gleichzeitig nie blendet, haben wir den Helligkeitsbereich exakt zwischen 30 und 70 festgeschrieben. Die For

Der Mittelpunkt (50): Das ist unsere Basishedlligkeit.
Die Schwingung (20): Der Sinus schlägt nach oben und unten aus, sodass wir genau bei minimal 30 und maximal 70 landen.

Die Geschwindigkeit (SPEED)

Wie schnell dein Licht „atmet“, bestimmst du über den Wert SPEED. In unserem Code nutzen wir einen Wert von 0.007.

Möchtest du es schneller? Erhöhe den Wert (z. B. auf 0.01).
Soll es noch ruhiger sein? Verringere den Wert (z. B. auf 0.004).

int helligkeit = 50 + (sin(pulsWinkel) * 20);

Der Arduino Code für das Nachtlicht

// www.kreativekiste.de
// 06.04.2026
// Version 1.1

#include <Adafruit_NeoPixel.h>

// --- PIN DEFINITIONEN ---
const int PIN_MIC = A2; 
const int PIN_NEO = A3; 
const int NUM_LEDS = 4; 

// --- EINSTELLUNGEN ---
const int SCHWELLENWERT = 600; // Klatsch-Empfindlichkeit
const float SPEED = 0.07;     // weniger = schneller 0.1, weniger = langsammer 0.0001

// --- OBJEKTE ---
Adafruit_NeoPixel pixels(NUM_LEDS, PIN_NEO, NEO_GRB + NEO_KHZ800);

// --- VARIABLEN ---
bool lichtAn = false;
float pulsWinkel = 0;    

void setup() {
  Serial.begin(9600);
  pixels.begin();
  pixels.clear();
  pixels.show();
  
  Serial.println(F("Nachtlicht V1.1 bereit (30-70 Helligkeit)"));
}

void loop() {
  // 1. MIKROFON ABFRAGEN
  int soundPegel = analogRead(PIN_MIC);

  if (soundPegel > SCHWELLENWERT) {
    lichtAn = !lichtAn; 
    
    if (!lichtAn) {
      pixels.clear();
      pixels.show();
    }
    
    Serial.print(F("Klatsch erkannt! Licht: "));
    Serial.println(lichtAn ? F("AN") : F("AUS"));
    
    delay(500); // Entprellen für das Klatschen
  }

  // 2. NACHTLICHT-EFFEKT (SANSFTES PULSIEREN)
  if (lichtAn) {
    // Berechnung für den Bereich 30 bis 70
    // sin() liefert -1 bis 1 -> * 20 ergibt -20 bis 20 -> + 50 ergibt 30 bis 70
    int helligkeit = 50 + (sin(pulsWinkel) * 20); 
    
    for (int i = 0; i < NUM_LEDS; i++) {
      pixels.setPixelColor(i, pixels.Color(helligkeit, 0, 0)); 
    }
    pixels.show();

    // Winkel für den nächsten Schritt erhöhen
    pulsWinkel += SPEED; 
    if (pulsWinkel >= 2 * PI) pulsWinkel = 0;
  }

  delay(20); // Stabilisierung der Schleife
}

3. Der Ultraschall-Einparksensor mit Anzeige

Wer kennt es nicht? Man rangiert rückwärts und hofft, dass der Platz noch reicht. Mit dem HC-SR04 Ultraschallsensor und deinem Arduino bauen wir uns einen zuverlässigen Assistenten, der Hindernisse zentimetergenau erkennt. Das Prinzip ist simpel: Der Sensor sendet einen Ton aus, der für uns Menschen unhörbar ist, fängt das Echo ein und berechnet aus der Zeitdifferenz den exakten Abstand.

Damit du das Projekt genau an deine Bedürfnisse anpassen kannst, habe ich den Code in drei verschiedenen Ausbaustufen vorbereitet:

1. Die Ampel-Version (Einfach & Klar)

Hier nutzt du die vier NeoPixel auf dem Shield als optische Warnanzeige.

Solange alles frei ist, leuchten die LEDs beruhigend Grün.
Kommst du dem Hindernis näher, schalten sie nacheinander auf Rot um. Diese Version ist perfekt für eine schnelle optische Rückmeldung ohne langes Ablesen von Werten.

2. Die Profi-Version (Zahlen im Blick)

Zusätzlich zu den farbigen LEDs nutzt du hier das 7-Segment-Display. Während die NeoPixel weiterhin die Farbe wechseln, bekommst du auf dem Display die exakte Entfernung in cm angezeigt. So weißt du beim Einparken im Regal oder in der Garage auf den Millimeter genau, wie viel Luft noch bleibt.

3. Die High-Tech-Version (Radar-Style)

Für alle, die es visuell lieben: Auf der 128-Bit-Pixel-Matrix (der 16x8 LED-Anzeige) simulierst du ein echtes Radar-Display. Je näher ein Objekt kommt, desto mehr "Wellen" oder Balken füllen das Display aus. Das sieht nicht nur extrem cool aus, sondern nutzt die volle grafische Power deines Shields, um den Raum vor dir digital abzubilden.

Der Arduino Code für den Einparksensor mit NeoPixel und Anzeige über Pixel Display

// www.kreativekiste.de // 04.04.2026 // Version 5.6

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_LEDBackpack.h>
#include <Adafruit_NeoPixel.h>

// Pins für den Ultraschallsensor
const int PIN_TRIG = 7;
const int PIN_ECHO = 8;

// Pins für Neopixel (Rich Shield TWO)
const int PIN_RGB = A3;
const int NUM_PIXELS = 4;

// Objekte initialisieren
Adafruit_8x16matrix matrix = Adafruit_8x16matrix();
Adafruit_NeoPixel pixels(NUM_PIXELS, PIN_RGB, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(9600);
  
  // 1. Matrix Setup
  matrix.begin(0x70);
  matrix.setRotation(1);      // Festgelegt für Text/Zahlen aus Joystick-Sicht
  matrix.setBrightness(3);    // Deine gewünschte Helligkeit
  matrix.setTextSize(1);      // Kleinstmöglicher Standard-Wert
  matrix.setTextColor(LED_ON);
  matrix.setTextWrap(false);  // Wichtig, damit die Zahl nicht umbricht
  
  // 2. Neopixel Setup (20% Helligkeit = 51)
  pixels.begin();
  pixels.setBrightness(51); 
  pixels.show();
  
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);

  Serial.println("Abstandsmesser: Optimierte Anzeige Größe 1");
}

void loop() {
  // 1. Ultraschall Messung
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  long dauer = pulseIn(PIN_ECHO, HIGH, 30000); 
  float entfernung = (dauer / 2.0) / 29.1;

  // 2. Anzeige auf der Matrix
  matrix.clear();
  
  // Wir setzen den Cursor auf (2, 1). 
  // Das lässt oben 1 Pixel Platz und rückt die Zahl leicht ein.
  matrix.setCursor(2, 1); 
  
  if (entfernung > 0 && entfernung < 100) {
    matrix.print((int)entfernung); 
  } else if (entfernung >= 100) {
    matrix.print("!!"); 
  }
  
  matrix.writeDisplay();

  // 3. Neopixel Logik (0-40 cm)
  pixels.clear();
  if (entfernung > 0 && entfernung <= 20) {
    int anzahl = (int)(entfernung / 5.0) + 1;
    if (anzahl > 4) anzahl = 4;
    for (int i = 0; i < anzahl; i++) pixels.setPixelColor(i, pixels.Color(0, 255, 0));
  } 
  else if (entfernung > 20 && entfernung <= 40) {
    int anzahl = (int)((entfernung - 20) / 5.0) + 1;
    if (anzahl > 4) anzahl = 4;
    for (int i = 0; i < anzahl; i++) pixels.setPixelColor(i, pixels.Color(255, 0, 0));
  }
  pixels.show();

  delay(100); 
}

Der Arduino Code für den Einparksensor mit 128 Pixel

// www.kreativekiste.de // 04.04.2026 // Version 5.1

#include <Wire.h>

const int PIN_US_TRIG = 7;
const int PIN_US_ECHO = 8;

// Speicher für das Display (16 Bytes für 128 LEDs)
uint8_t matrixBuffer[16];

void setup() {
  Serial.begin(9600);
  Wire.begin();

  pinMode(PIN_US_TRIG, OUTPUT);
  pinMode(PIN_US_ECHO, INPUT);

  initHT16K33(0x70);
  
  Serial.println("Abstandsmesser: 16 echte vertikale Reihen (0-32cm) | Helligkeit: 3");
}

void loop() {
  // 1. Ultraschall Messung
  digitalWrite(PIN_US_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_US_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_US_TRIG, LOW);

  long dauer = pulseIn(PIN_US_ECHO, HIGH, 30000); 
  float entfernung = (dauer / 2.0) / 29.1;

  // 2. Berechnung: 0 bis 16 Pixelreihen (2 cm pro Pixel)
  int reihen = (int)(entfernung / 2.0);
  if (reihen > 16) reihen = 16;
  if (reihen < 0) reihen = 0;

  // 3. Anzeige-Buffer leeren
  for(int i = 0; i < 16; i++) matrixBuffer[i] = 0;

  // 4. MAPPING: 16 Reihen hochkant (Vertikal)
  // Wir nutzen die 8 Bits in den Registern als vertikale Stufen
  for (int r = 0; r < 16; r++) {
    if (r < reihen) {
      // Bestimmen, ob wir im unteren (0-7) oder oberen (8-15) Block sind
      int byteOffset = (r < 8) ? 0 : 1; 
      int bitPos = r % 8; // Das entsprechende Bit in der Reihe (0-7)
      
      // Wir setzen dieses Bit in allen 8 Spalten der Breite
      for (int col = 0; col < 8; col++) {
        // Die 8 Spalten liegen auf den Registern 0, 2, 4... 14 (und +1 für Block 2)
        matrixBuffer[col * 2 + byteOffset] |= (1 << bitPos);
      }
    }
  }

  // 5. Daten an das Display senden
  Wire.beginTransmission(0x70);
  Wire.write(0x00); 
  for (int i = 0; i < 16; i++) {
    Wire.write(matrixBuffer[i]);
  }
  Wire.endTransmission();

  // Kontrolle
  Serial.print("Abstand: ");
  Serial.print(entfernung);
  Serial.print(" cm | Stufe: ");
  Serial.println(reihen);

  delay(50); 
}

void initHT16K33(byte addr) {
  Wire.beginTransmission(addr);
  Wire.write(0x21); Wire.endTransmission(); // System an
  
  Wire.beginTransmission(addr);
  Wire.write(0x81); Wire.endTransmission(); // Display an, kein Blinken
  
  // Helligkeit einstellen: 0xE0 (aus) bis 0xEF (max)
  // 0xE3 entspricht Helligkeitsstufe 3
  Wire.beginTransmission(addr);
  Wire.write(0xE3); Wire.endTransmission();
}

Der Arduino Code für den Einparksensor mit Neopixel

// www.kreativekiste.de // 04.04.2026 // Version 5.3

#include <Adafruit_NeoPixel.h>

// Pins für den Ultraschallsensor
const int PIN_TRIG = 7;
const int PIN_ECHO = 8;

// Dein angepasster Pin für die Neopixel
const int PIN_RGB = A3;
const int NUM_PIXELS = 4;

// Neopixel Objekt erstellen
Adafruit_NeoPixel pixels(NUM_PIXELS, PIN_RGB, NEO_GRB + NEO_KHZ800);

void setup() {
  Serial.begin(9600);
  
  // Neopixel starten
  pixels.begin();
  
  // Helligkeit auf 20% (20% von 255 ist 51)
  pixels.setBrightness(10);
  pixels.show(); // Alle LEDs beim Start aus
  
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);

  Serial.println("Abstandsmesser (0-40 cm) | Pin A3 | Helligkeit 20%");
}

void loop() {
  // 1. Ultraschall Messung
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  long dauer = pulseIn(PIN_ECHO, HIGH, 30000); 
  float entfernung = (dauer / 2.0) / 29.1;

  // 2. LEDs erst mal alle ausmachen
  pixels.clear();

  // 3. Logik für die Anzeige (0-40 cm)
  if (entfernung > 0 && entfernung <= 20) {
    // BEREICH 0-20 cm: GRÜN
    // Alle 5 cm leuchtet eine LED mehr
    int anzahlGruen = (int)(entfernung / 5.0) + 1;
    if (anzahlGruen > 4) anzahlGruen = 4;

    for (int i = 0; i < anzahlGruen; i++) {
      pixels.setPixelColor(i, pixels.Color(0, 255, 0)); // Grün
    }
  } 
  else if (entfernung > 20 && entfernung <= 40) {
    // BEREICH 20-40 cm: ROT
    // Zählt ab 20 cm wieder von 1 bis 4 LEDs hoch
    int anzahlRot = (int)((entfernung - 20) / 5.0) + 1;
    if (anzahlRot > 4) anzahlRot = 4;

    for (int i = 0; i < anzahlRot; i++) {
      pixels.setPixelColor(i, pixels.Color(255, 0, 0)); // Rot
    }
  }

  // 4. Daten an die LEDs senden
  pixels.show();

  // Serielle Kontrolle
  Serial.print("Abstand: ");
  Serial.print(entfernung);
  Serial.println(" cm");

  delay(100); 
}

4. Das Stimmungs-Barometer, Licht-Design per Handrad

Manchmal muss es einfach die perfekte Farbe sein: Ein warmes Orange zum Lesen, ein tiefes Blau zum Entspannen oder ein kühles Lila für die Gaming-Session. Mit deinem Stimmungs-Barometer baust du dir eine intuitive Lichtsteuerung, bei der du die drei Grundfarben Rot, Grün und Blau (RGB) stufenlos mischst.

Die Herausforderung: Blindes Mischen?

Wenn du drei Farben mit nur einem Knopf steuerst, verlierst du ohne Display schnell den Überblick. Verändere ich gerade den Rot-Anteil oder bin ich schon bei Blau? Um das zu lösen, haben wir ein visuelles User-Interface direkt in die LEDs programmiert: den Indikator-Flash.

Das Feature: Der 0,3-Sekunden-Blitz

Jedes Mal, wenn du den Encoder-Knopf (SW4) los lässt, passiert Folgendes:

Optisches Feedback: Die vier NeoPixel blitzen für exakt 300 ms in der Farbe auf, die du jetzt gerade verstellst (z. B. leuchtet alles kurz kräftig Grün).
Sofort-Reset: Direkt nach dem Blitz springen die LEDs automatisch zu deinem mühsam gemischten Farbergebnis zurück – und zwar völlig unabhängig davon, wie lange du den Finger noch auf dem Taster lässt.
Interaktive Justierung: Jetzt kannst du den gewählten Kanal im Bereich von 0 bis 180 feinjustieren.
- Warum nur bis 180? Ein voller RGB-Wert geht normalerweise bis 255. Das schont nicht nur die Augen, sondern sorgt auch dafür, dass die Stromversorgung über USB stabil bleibt und die LEDs eine deutlich längere Lebensdauer haben.

Der Arduino Code für das Stimmungsbarometer

// www.kreativekiste.de
// 06.04.2026
// Version 1.4

#include <Adafruit_NeoPixel.h>

// --- PIN DEFINITIONEN ---
const int PIN_CLK = 2;
const int PIN_DT  = 3;
const int PIN_SW  = 4;
const int PIN_NEO = A3;
const int NUM_LEDS = 4;

// --- OBJEKTE ---
Adafruit_NeoPixel pixels(NUM_LEDS, PIN_NEO, NEO_GRB + NEO_KHZ800);

// --- VARIABLEN ---
int r = 0, g = 0, b = 0;
int modus = 0; 
bool letzterButtonZustand = HIGH;
volatile int encoderDelta = 0;

// --- ENCODER INTERRUPT ---
void isrEncoder() {
  if (digitalRead(PIN_CLK) != digitalRead(PIN_DT)) {
    encoderDelta = 2;  
  } else {
    encoderDelta = -2; 
  }
}

void setup() {
  Serial.begin(9600);
  pinMode(PIN_CLK, INPUT_PULLUP);
  pinMode(PIN_DT, INPUT_PULLUP);
  pinMode(PIN_SW, INPUT_PULLUP);
  
  attachInterrupt(digitalPinToInterrupt(PIN_CLK), isrEncoder, FALLING);
  
  pixels.begin();
  pixels.show();
  
  Serial.println(F("Stimmungs-Barometer V1.4 bereit!"));
}

void loop() {
  // 1. TASTER ABFRAGEN & MODUS-WECHSEL
  bool aktuellerButton = digitalRead(PIN_SW);
  
  if (aktuellerButton == LOW && letzterButtonZustand == HIGH) {
    delay(50); // Entprellen
    if (digitalRead(PIN_SW) == LOW) {
      modus++;
      if (modus > 2) modus = 0;
      
      // SCHRITT A: Den Blitz anzeigen
      pixels.clear();
      if (modus == 0) pixels.fill(pixels.Color(120, 0, 0)); 
      if (modus == 1) pixels.fill(pixels.Color(0, 120, 0)); 
      if (modus == 2) pixels.fill(pixels.Color(0, 0, 120)); 
      pixels.show();
      
      // SCHRITT B: Exakt 0,3 Sekunden warten
      delay(300); 
      
      // SCHRITT C: Sofort zurück zur Mischfarbe (auch wenn noch gedrückt ist!)
      for (int i = 0; i < NUM_LEDS; i++) {
        pixels.setPixelColor(i, pixels.Color(r, g, b));
      }
      pixels.show();

      // SCHRITT D: Warten, bis der Finger weg ist, ohne die LEDs zu blockieren
      while (digitalRead(PIN_SW) == LOW) { 
        // Hier passiert nichts, die Mischfarbe leuchtet bereits wieder
        delay(10); 
      }
    }
  }
  letzterButtonZustand = aktuellerButton;

  // 2. ENCODER-WERTE ANPASSEN (0-180)
  if (encoderDelta != 0) {
    if (modus == 0) r = constrain(r + encoderDelta, 0, 180);
    if (modus == 1) g = constrain(g + encoderDelta, 0, 180);
    if (modus == 2) b = constrain(b + encoderDelta, 0, 180);
    
    encoderDelta = 0; 
    
    Serial.print(F("Mix -> R: ")); Serial.print(r);
    Serial.print(F(" | G: ")); Serial.print(g);
    Serial.print(F(" | B: ")); Serial.println(b);
  }

  // 3. PERMANENTE AUSGABE DER MISCHFARBE
  // Wird im normalen Betrieb ständig aktualisiert
  for (int i = 0; i < NUM_LEDS; i++) {
    pixels.setPixelColor(i, pixels.Color(r, g, b));
  }
  pixels.show();
  
  delay(10); 
}

1.1 Projekt-Update: Shield Invaders, jetzt mit Hard-Mode!

Unser Retro-Shooter für das Rich Shield Two hat ein massives Upgrade erhalten. Wir haben nicht nur an der Steuerung gefeilt, sondern auch zwei grundlegend verschiedene Spielmodi implementiert, damit sowohl Einsteiger als auch Profis auf ihre Kosten kommen.

Die Evolution des Gameplays: Zwei Wege zum Highscore

Je nachdem, wie „gnadenlos“ du dein Spiel programmieren möchtest, gibt es zwei Varianten, wie das System mit durchbrechenden Aliens umgeht:

Version „Casual“ (Punktabzug): In der klassischen Variante ist ein durchgeschlüpftes Alien ärgerlich, aber nicht das Ende. Dir wird lediglich ein Punkt vom Score abgezogen. Ideal, um entspannt zu zocken oder das Handling mit dem Joystick zu üben.
Version „Hard-Mode“ (Durchbruch = Game Over): Hier wird es ernst! Ein einziges Alien, das den unteren Rand der Matrix ($y > 15$) erreicht, führt sofort zum Game Over. Das verwandelt das Spiel in eine hochintensive Gebietsverteidigung, bei der kein Fehler verziehen wird.

Borderless Movement: Mehr Freiheit am Rand

Ein echtes Highlight der neuen Version ist das optimierte Bewegungsprofil deines Raumschiffs. In früheren Versionen war das Schiff an den physischen Rand der 8-Pixel-Matrix gebunden. Jetzt haben wir „Borderless Movement“ eingebaut.

Dein Schiff kann nun mit einer Tragfläche aus dem Display ragen, warum? Damit du Aliens, die ganz am Rand erscheinen, mit deiner mittig platzierten Kanone perfekt ins Visier nehmen kannst. Die GFX-Library schneidet die nicht sichtbaren Pixel einfach automatisch ab, technisch sauber und spielerisch ein riesiger Vorteil!

Der Tacho am Bar-Graph

Damit du während der Action weißt, wie schnell die Einschläge kommen, dient die Batterie-Anzeige (TM1651) als Echtzeit-Tacho. Je mehr Balken leuchten, desto weniger Zeit bleibt dir zum Zielen. Ein kurzer Blick auf die Anzeige verrät dir sofort: Ist es noch Training oder schon purer Überlebenskampf?

Der Arduino Code für das Space-Invader Spiel, mit Durchbruch gameplay

// www.kreativekiste.de
// 06.04.2026
// Version 1.4

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_LEDBackpack.h>
#include <TM1651.h>

// --- PIN DEFINITIONEN ---
const int PIN_JOY_X = A1; 
const int PIN_JOY_SW = 4;  
const int PIN_BCLK = 10;   
const int PIN_BDIO = 11;   

// --- OBJEKTE ---
Adafruit_8x16matrix matrix = Adafruit_8x16matrix();
TM1651 batterie(PIN_BCLK, PIN_BDIO);

// --- SPIEL-VARIABLEN ---
int playerX = 3;            // Startposition
const int playerY = 14;     
unsigned long lastMove = 0;
const int playerSpeed = 120; // Etwas direktere Steuerung

int bulletX = -1, bulletY = -1;
bool bulletActive = false;
unsigned long lastBulletMove = 0;

int alienX = -1, alienY = -1, alienW = 0, alienH = 0;
bool alienActive = false;
unsigned long lastAlienMove = 0;
int alienSpeed = 500; 

bool gameOver = false;
int score = 0;

void aktualisiereTacho() {
  int level = map(alienSpeed, 500, 100, 1, 7);
  batterie.displayLevel(constrain(level, 1, 7));
}

void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(A2));
  
  pinMode(PIN_JOY_SW, INPUT);
  
  matrix.begin(0x70);
  matrix.setRotation(0);
  matrix.setTextColor(LED_ON);
  matrix.setTextWrap(false);

  batterie.init();
  batterie.set(BRIGHT_TYPICAL);
  
  aktualisiereTacho(); 
  Serial.println(F("Shield Invaders V1.4 - Hard Mode & Borderless active"));
}

void loop() {
  if (gameOver) {
    batterie.displayLevel(7);
    matrix.clear();
    matrix.setCursor(0, 0);
    matrix.print(F("X")); // Signalisiert das Durchbrechen der Aliens
    matrix.writeDisplay();
    delay(2000);
    matrix.clear();
    
    while (digitalRead(PIN_JOY_SW) == HIGH) { delay(10); }
    resetGame();
    return;
  }
  
  matrix.clear();

  // 1. STEUERUNG (Jetzt mit Borderless Move: -1 bis 6)
  int joyX = analogRead(PIN_JOY_X);
  if (millis() - lastMove > playerSpeed) {
    if (joyX < 300) { playerX = constrain(playerX - 1, -1, 6); lastMove = millis(); }
    if (joyX > 700) { playerX = constrain(playerX + 1, -1, 6); lastMove = millis(); }
  }
  
  if (digitalRead(PIN_JOY_SW) == HIGH && !bulletActive) {
    bulletX = playerX + 1;
    bulletY = playerY - 1;
    bulletActive = true;
    delay(150); 
  }

  // 2. ZEICHNEN (GFX Library clippt automatisch bei x < 0)
  matrix.drawFastHLine(playerX, playerY + 1, 3, LED_ON);
  matrix.drawPixel(playerX + 1, playerY, LED_ON);

  // 3. SCHUSS
  if (bulletActive) {
    if (millis() - lastBulletMove > 40) {
      bulletY--;
      lastBulletMove = millis();
      if (bulletY < 0) bulletActive = false;
    }
    if (bulletActive) matrix.drawPixel(bulletX, bulletY, LED_ON);
  }

  // 4. ALIENS
  if (!alienActive) {
    alienX = random(0, 8);
    alienW = random(1, 4);
    alienH = random(1, 4);
    alienY = -alienH;
    if (alienX + alienW > 8) alienX = 8 - alienW;
    alienActive = true;
  }
  
  if (alienActive) {
    if (millis() - lastAlienMove > alienSpeed) {
      alienY++;
      lastAlienMove = millis();
      
      // Check: Alien am Spieler vorbei? -> GAME OVER
      if (alienY > 15) {
        gameOver = true; 
        Serial.println(F("Alien durchgebrochen!"));
      }
      
      // Kollision mit dem Schiff
      if (alienY + alienH >= playerY && !gameOver) {
        if (!(alienX + alienW <= playerX || alienX >= playerX + 3)) {
          gameOver = true;
        }
      }
    }
    if (!gameOver) matrix.fillRect(alienX, alienY, alienW, alienH, LED_ON);
  }
  
  // 5. TREFFER
  if (bulletActive && alienActive) {
    if (bulletX >= alienX && bulletX < alienX + alienW &&
        bulletY >= alienY && bulletY < alienY + alienH) {
      alienActive = false;
      bulletActive = false;
      score += 10;
      alienSpeed = max(80, alienSpeed - 15); // Schnellerer Anstieg
      aktualisiereTacho(); 
    }
  }

  matrix.writeDisplay();
  delay(15); 
}

void resetGame() {
  gameOver = false;
  score = 0;
  playerX = 3;
  alienActive = false;
  bulletActive = false;
  alienSpeed = 500;
  aktualisiereTacho();
}

Der Arduino Code für das Space-Invader Spiel, ohne Durchburch gameplay

// www.kreativekiste.de
// 06.04.2026
// Version 1.3

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_LEDBackpack.h>
#include <TM1651.h>

// --- PIN DEFINITIONEN ---
const int PIN_JOY_X = A1; 
const int PIN_JOY_SW = 4;  // Taster im Joystick
const int PIN_BCLK = 10;   // Batterie-Anzeige Clock
const int PIN_BDIO = 11;   // Batterie-Anzeige Data

// --- OBJEKTE ---
Adafruit_8x16matrix matrix = Adafruit_8x16matrix();
TM1651 batterie(PIN_BCLK, PIN_BDIO);

// --- SPIEL-VARIABLEN ---
int playerX = 3;
const int playerY = 14;
unsigned long lastMove = 0;
const int playerSpeed = 150;

int bulletX = -1, bulletY = -1;
bool bulletActive = false;
unsigned long lastBulletMove = 0;

int alienX = -1, alienY = -1, alienW = 0, alienH = 0;
bool alienActive = false;
unsigned long lastAlienMove = 0;
int alienSpeed = 500; // Start-Geschwindigkeit in ms

bool gameOver = false;
int score = 0;

// HILFSFUNKTION FUER DEN TACHO
void aktualisiereTacho() {
  // Map: 500ms (langsam) -> 1 Balken | 100ms (schnell) -> 7 Balken
  int level = map(alienSpeed, 500, 100, 1, 7);
  batterie.displayLevel(constrain(level, 1, 7));
}

void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(A2));
  
  pinMode(PIN_JOY_SW, INPUT);
  
  matrix.begin(0x70);
  matrix.setRotation(0);
  matrix.setTextColor(LED_ON);
  matrix.setTextWrap(false);

  batterie.init();
  batterie.set(BRIGHT_TYPICAL);
  
  aktualisiereTacho(); 
  
  Serial.println(F("Shield Invaders V1.3 - Purist Mode"));
}

void loop() {
  if (gameOver) {
    batterie.displayLevel(7); // Vollausschlag bei Ende

    matrix.clear();
    matrix.setCursor(0, 0);
    matrix.print(F("X"));
    matrix.writeDisplay();
    delay(2000);
    matrix.writeDisplay();
    
    // Warten auf Neustart
    while (digitalRead(PIN_JOY_SW) == HIGH) { delay(10); }
    resetGame();
    return;
  }
  
  matrix.clear();

  // 1. STEUERUNG (LINKS/RECHTS)
  int joyX = analogRead(PIN_JOY_X);
  if (millis() - lastMove > playerSpeed) {
    if (joyX < 300) { playerX = constrain(playerX - 1, 0, 5); lastMove = millis(); }
    if (joyX > 700) { playerX = constrain(playerX + 1, 0, 5); lastMove = millis(); }
  }
  
  if (digitalRead(PIN_JOY_SW) == HIGH && !bulletActive) {
    bulletX = playerX + 1;
    bulletY = playerY - 1;
    bulletActive = true;
    delay(200); // Entprellen
  }

  // 2. ZEICHNEN (SPIELER)
  matrix.drawFastHLine(playerX, playerY + 1, 3, LED_ON);
  matrix.drawPixel(playerX + 1, playerY, LED_ON);

  // 3. SCHUSS BEWEGEN
  if (bulletActive) {
    if (millis() - lastBulletMove > 50) {
      bulletY--;
      lastBulletMove = millis();
      if (bulletY < 0) bulletActive = false;
    }
    if (bulletActive) matrix.drawPixel(bulletX, bulletY, LED_ON);
  }

  // 4. ALIENS VERWALTEN
  if (!alienActive) {
    alienX = random(0, 6);
    alienW = random(1, 4);
    alienH = random(1, 4);
    alienY = -alienH;
    alienW = constrain(alienW, 1, 8 - alienX);
    alienActive = true;
  }
  
  if (alienActive) {
    if (millis() - lastAlienMove > alienSpeed) {
      alienY++;
      lastAlienMove = millis();
      
      // Kollision mit dem Schiff
      if (alienY + alienH >= playerY) {
        if (!(alienX + alienW <= playerX || alienX >= playerX + 3)) {
          gameOver = true;
        }
      }
      
      if (alienY > 15) {
        alienActive = false;
        score = max(0, score - 1); // Kleiner Punktabzug bei verpassten Aliens
      }
    }
    matrix.fillRect(alienX, alienY, alienW, alienH, LED_ON);
  }
  
  // 5. TREFFER-LOGIK
  if (bulletActive && alienActive) {
    if (bulletX >= alienX && bulletX < alienX + alienW &&
        bulletY >= alienY && bulletY < alienY + alienH) {
      alienActive = false;
      bulletActive = false;
      score += 10;
      
      // Schwierigkeit erhoehen
      alienSpeed = max(100, alienSpeed - 20); 
      aktualisiereTacho(); 
    }
  }

  matrix.writeDisplay();
  delay(20); 
}

void resetGame() {
  gameOver = false;
  score = 0;
  playerX = 3;
  alienActive = false;
  bulletActive = false;
  alienSpeed = 500;
  aktualisiereTacho();
}

Arduino Ideen

Spiele, MINT Ideen und Projekte auf dem Open Smart Rich Shield V2