Elektronischer Würfel mit Arduino Nano bauen: 7 LEDs, Zufallszahlen & Touch-Auslöser

Warum ausgerechnet ein Würfel?

Der elektronische Würfel ist so beliebt, weil er alles vereint, was ein gutes Lernprojekt braucht: Er sieht am Ende richtig cool aus, ist an einem Nachmittag gebaut, und er zwingt dich, ein paar zentrale Programmier-Konzepte zu verstehen – aber alle in einer harmlosen, spielerischen Verpackung. Du lernst, mehrere LEDs sauber über ein Array anzusteuern, aus einer Zufallszahl ein Augenmuster abzuleiten und einen Taster (hier: einen Touch-Sensor) sauber abzufragen.

Als Gehirn nutzen wir den Arduino Nano V3. Er ist winzig, lässt sich direkt aufs Breadboard stecken und hat mehr als genug Pins für sieben LEDs und einen Sensor. Wenn du die Grundlagen des Nano noch nicht kennst, hilft dir vorab der Artikel Arduino Nano V3 Einsteiger-Tutorial.

Das brauchst du

1Die LED-Positionen und der Trick mit den Gruppen

Wir ordnen die sieben LEDs im typischen Würfelmuster an: vier Ecken, zwei Seitenmitten und ein Zentrum. Statt sie einzeln zu verkabeln, fassen wir sie zu vier Gruppen zusammen, die immer gemeinsam leuchten. Das spart Pins und macht den Code elegant:

Jede LED bekommt ihren eigenen 330-Ω-Vorwiderstand in Reihe. Die Kathode (kurzes Beinchen) geht auf GND, die Anode über den Widerstand an den jeweiligen Nano-Pin. Warum der Widerstand Pflicht ist und wie du seinen Wert exakt berechnest, erklärt der Artikel LED-Vorwiderstand berechnen.

2Verkabelung des Touch-Sensors

Der TTP223 hat drei Pins und ist im Handumdrehen angeschlossen:

Standardmäßig gibt der Sensor HIGH aus, solange du ihn berührst, und LOW, wenn nicht. Genau dieses Verhalten fragen wir im Code ab.

3Erster Test: Alle LEDs durchschalten

Bevor wir würfeln, prüfen wir, ob alle vier Gruppen richtig verkabelt sind. Dieser Sketch schaltet sie nacheinander an und aus – so siehst du sofort, ob eine LED falsch herum steckt oder ein Pin vertauscht ist.

// Pins der vier LED-Gruppen
const int A = 2;   // Zentrum
const int B = 3;   // Diagonale 1
const int C = 4;   // Diagonale 2
const int D = 5;   // Seitenmitten

int gruppen[] = {A, B, C, D};

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(gruppen[i], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < 4; i++) {
    digitalWrite(gruppen[i], HIGH);
    delay(400);
    digitalWrite(gruppen[i], LOW);
  }
}

Leuchten alle Gruppen der Reihe nach auf, stimmt die Verkabelung. Falls eine LED dunkel bleibt, ist sie meist verpolt (kurzes und langes Beinchen vertauscht) oder der Vorwiderstand hat keinen Kontakt.

4Eine Augenzahl anzeigen

Jetzt bringen wir dem Würfel bei, aus einer Zahl das richtige Muster zu machen. Wir schreiben eine Funktion zeigeZahl(), die je nach Wert die passenden Gruppen einschaltet – genau nach der Logik aus Schritt 1.

const int A = 2, B = 3, C = 4, D = 5;

void setup() {
  pinMode(A, OUTPUT); pinMode(B, OUTPUT);
  pinMode(C, OUTPUT); pinMode(D, OUTPUT);
}

void alleAus() {
  digitalWrite(A, LOW); digitalWrite(B, LOW);
  digitalWrite(C, LOW); digitalWrite(D, LOW);
}

void zeigeZahl(int zahl) {
  alleAus();
  switch (zahl) {
    case 1: digitalWrite(A, HIGH); break;
    case 2: digitalWrite(B, HIGH); break;
    case 3: digitalWrite(A, HIGH); digitalWrite(B, HIGH); break;
    case 4: digitalWrite(B, HIGH); digitalWrite(C, HIGH); break;
    case 5: digitalWrite(A, HIGH); digitalWrite(B, HIGH);
            digitalWrite(C, HIGH); break;
    case 6: digitalWrite(B, HIGH); digitalWrite(C, HIGH);
            digitalWrite(D, HIGH); break;
  }
}

void loop() {
  // Test: zaehlt 1..6 durch
  for (int z = 1; z <= 6; z++) {
    zeigeZahl(z);
    delay(1000);
  }
}

5Echte Zufallszahlen erzeugen

Ein Würfel, der immer dieselbe Reihenfolge zeigt, wäre langweilig. Arduino hat dafür die Funktion random() – aber Achtung: Ohne Vorbereitung liefert sie nach jedem Neustart dieselbe Zahlenfolge. Der Trick ist randomSeed(): Wir füttern den Zufallsgenerator mit dem Rauschen eines unbeschalteten Analogpins, das bei jedem Start anders ausfällt.

void setup() {
  // A0 ist NICHT verkabelt -> liefert zufaelliges Rauschen
  randomSeed(analogRead(A0));
}

void loop() {
  int wurf = random(1, 7);   // Zahl von 1 bis 6 (7 ist ausgeschlossen)
  // ... zeigeZahl(wurf) ...
}

6Der komplette Würfel mit Roll-Animation

Jetzt fügen wir alles zusammen: Berührst du den Touch-Sensor, flackert der Würfel kurz durch zufällige Zahlen (die "Roll-Animation"), wird langsamer und bleibt schließlich auf dem Ergebnis stehen. Das fühlt sich viel lebendiger an als eine Zahl, die einfach nur aufpoppt.

const int A = 2, B = 3, C = 4, D = 5;
const int TOUCH = 7;

void setup() {
  pinMode(A, OUTPUT); pinMode(B, OUTPUT);
  pinMode(C, OUTPUT); pinMode(D, OUTPUT);
  pinMode(TOUCH, INPUT);
  randomSeed(analogRead(A0));
  zeigeZahl(6);   // Startbild
}

void alleAus() {
  digitalWrite(A, LOW); digitalWrite(B, LOW);
  digitalWrite(C, LOW); digitalWrite(D, LOW);
}

void zeigeZahl(int zahl) {
  alleAus();
  switch (zahl) {
    case 1: digitalWrite(A, HIGH); break;
    case 2: digitalWrite(B, HIGH); break;
    case 3: digitalWrite(A, HIGH); digitalWrite(B, HIGH); break;
    case 4: digitalWrite(B, HIGH); digitalWrite(C, HIGH); break;
    case 5: digitalWrite(A, HIGH); digitalWrite(B, HIGH);
            digitalWrite(C, HIGH); break;
    case 6: digitalWrite(B, HIGH); digitalWrite(C, HIGH);
            digitalWrite(D, HIGH); break;
  }
}

void wuerfeln() {
  // Roll-Animation: schnelle Zahlen, die langsamer werden
  int pause = 40;
  for (int i = 0; i < 20; i++) {
    zeigeZahl(random(1, 7));
    delay(pause);
    pause += 8;          // wird von Schritt zu Schritt langsamer
  }
  // Endergebnis
  int ergebnis = random(1, 7);
  zeigeZahl(ergebnis);
}

void loop() {
  if (digitalRead(TOUCH) == HIGH) {   // Sensor beruehrt?
    wuerfeln();
    delay(300);                       // kurze Sperre gegen Doppelausloesung
  }
}

Lade den Sketch hoch, tippe auf den Touch-Sensor – und dein Würfel rollt. Die Animation wird durch das langsam wachsende pause von Durchgang zu Durchgang träger, genau wie ein echter Würfel, der ausrollt.

Troubleshooting