LED-Würfel mit Arduino: 3x3x3 und 4x4x4 bauen und programmieren

Ein LED-Würfel (LED Cube) gehört zu den eindrucksvollsten Lichtprojekten, die du mit einem Arduino bauen kannst: LEDs in einem dreidimensionalen Raster leuchten Ebene für Ebene auf und zeichnen rotierende Flächen, fallende Regentropfen und Würfel, die in der Luft wachsen und schrumpfen. Für deinen ersten LED-Würfel mit Arduino ist die Größe 3x3x3 (27 LEDs) oder 4x4x4 (64 LEDs) ideal; dafür reichen die Pins eines Arduino Uno, ein paar Transistoren und etwas Geduld beim Löten. Der Trick: Statt jeder LED einen eigenen Pin zu geben, nutzt du das Ebenen-Säulen-Multiplexing. So steuerst du 27 LEDs mit 12 Pins und 64 LEDs mithilfe von zwei 74HC595-Chips mit nur 7 Pins.

In dieser Anleitung lernst du, wie ein LED-Würfel funktioniert, wie du eine Lötschablone baust, wie du die Ebenen Schritt für Schritt verbindest, warum die Ebenen über Transistoren geschaltet werden müssen und wie man die Widerstände berechnet. Danach findest du Arduino-Code, der auf einem 3x3x3-Würfel Animationen aus Arrays abspielt, die Erweiterung auf einen 4x4x4-Würfel mit dem 74HC595, Versionen für ESP32 und Raspberry Pi Pico (MicroPython), WS2812B als Alternative für einen farbigen Würfel und Lösungen für die häufigsten Aufbaufehler wie verpolte LEDs oder kalte Lötstellen.

Was ist ein LED-Würfel und wie funktioniert er?

Ein LED-Würfel entsteht, indem man waagerechte Ebenen aus gleichmäßig angeordneten LEDs übereinanderstapelt. In jeder Ebene werden die Kathodenbeine (−) aller LEDs miteinander verlötet, sodass jede Ebene eine einzige gemeinsame Kathodenleitung hat. Die Anodenbeine (+) übereinanderliegender LEDs werden senkrecht verlötet und bilden die Säulen. Ein 3x3x3-Würfel hat 3 Ebenen und 9 Säulen, ein 4x4x4-Würfel 4 Ebenen und 16 Säulen. Jede LED sitzt genau am Schnittpunkt einer Ebene und einer Säule: Um eine LED einzuschalten, legst du an ihre Säule eine positive Spannung und verbindest ihre Ebene mit GND.

Jede LED im Würfel lässt sich mit drei Koordinaten beschreiben: x (von links nach rechts), y (von vorne nach hinten) und z (von unten nach oben). Im Code dieses Artikels wird die Säulennummer mit c = y × 3 + x berechnet (beim 4x4x4 c = y × 4 + x), z ist die Ebenennummer. Ähnlich wie ein Pixel auf einem Bildschirm heißt ein einzelner Lichtpunkt im Würfel Voxel (Volumenpixel). Eine Animation zu erstellen bedeutet im Grunde, zu entscheiden, welche Voxel zu welchem Zeitpunkt leuchten.

Wie funktioniert Ebenen-Säulen-Multiplexing?

Schaltest du mehrere Ebenen gleichzeitig ein, lässt die positive Spannung an einer Säule in jeder aktiven Ebene dieser Säule eine LED leuchten; das gewünschte Muster bekommst du so nicht hin. Deshalb wird der Würfel Ebene für Ebene abgetastet: Der Arduino schaltet zuerst alle Ebenen aus, schreibt das Säulenmuster der ersten Ebene auf die Pins, schaltet nur diese Ebene für einige Millisekunden ein, schaltet sie wieder aus und geht zur zweiten Ebene über. Wiederholt sich diese Schleife mehr als hundertmal pro Sekunde, hält dein Auge das Licht kurz fest (Trägheit des Auges), und du siehst alle Ebenen gleichzeitig leuchten.

Die Abtastrate lässt sich leicht berechnen: Bildwiederholrate = 1 / (Anzahl der Ebenen × Zeit pro Ebene). Lässt du beim 3x3x3-Würfel jede Ebene 3 ms an, dauert ein Durchlauf 9 ms, und der Würfel wird etwa 110-mal pro Sekunde aufgefrischt. Beim 4x4x4 mit 2 ms pro Ebene dauert ein Durchlauf 8 ms, das ergibt 125 Hz. Unter 50–60 Hz bemerkt das Auge ein Flimmern; über 100 Hz wirkt er für das Auge völlig ruhig, und auf Handyvideos entstehen weniger Streifen. Der Preis ist die Helligkeit: Weil jede Ebene nur 1/3 der Zeit leuchtet (beim 4x4x4 nur 1/4), sinkt der mittlere Strom einer LED auf diesen Bruchteil ihres Momentanstroms.

Materialliste

Eine Lötschablone bauen

Das Geheimnis eines sauberen Würfels ist die Schablone. Lötest du die LEDs freihändig, verrutschen die Abstände, die Ebenen werden schief und der Würfel sieht verzogen aus. Die Schablone ist ein Holzstück mit gleichmäßig verteilten Löchern, in denen die LEDs kopfüber sitzen, also mit der Kuppel nach unten. Den Abstand bestimmt die Länge des Kathodenbeins: Bei den meisten 5-mm-LEDs ist das kurze Bein etwa 25 mm lang, miss deine eigenen LEDs aber mit dem Lineal nach. Wenn du das Bein 2–3 mm vom Gehäuse entfernt um 90° biegst, sollte der waagerechte Rest das Bein der Nachbar-LED um 2–3 mm überlappen; deshalb sind 20 mm Abstand ein guter Ausgangspunkt.

1. Zeichne mit dem Lineal ein 3x3- (oder 4x4-) Raster auf Sperrholz, MDF oder dicke Pappe, mit 20 mm zwischen den Punkten und mindestens 2 cm Rand.
2. Markiere jeden Punkt zuerst mit einem Nagel und bohre ihn dann senkrecht mit einem 5-mm-Bohrer. Die LED soll fest im Loch sitzen, sich aber ohne Kraft herausziehen lassen; ist sie zu stramm, weite das Loch leicht auf.
3. Zeichne an einer Kante der Schablone einen Pfeil für die Richtung der Kathode; das kurze Bein jeder LED zeigt in dieselbe Richtung.
4. Bereite vier gleich hohe Abstandshalter vor, die zu deinem Ebenenabstand passen und beim Verbinden die obere Ebene tragen; Reste von Holzleisten oder gefaltete Pappe reichen.

Aufbau Schritt für Schritt: Ebenen und Säulen

1. Beine biegen: Biege das kurze Bein (Kathode) jeder LED 2–3 mm vom Gehäuse entfernt um 90° waagerecht in Pfeilrichtung der Schablone. Das lange Bein (Anode) bleibt senkrecht.
2. Erste Ebene bestücken: Setze die LEDs mit der Kuppel nach unten in die Löcher. Jedes Kathodenbein einer Reihe soll das Kathodenbein der nächsten LED berühren; das Bein der letzten LED einer Reihe darf frei bleiben.
3. Kathoden verlöten: Löte jede Kontaktstelle bei 320–350 °C Lötspitzentemperatur in höchstens 2–3 Sekunden. Löte dann einen geraden Draht (ein abgeschnittenes Widerstandsbein oder verzinnten Kupferdraht) quer über die Enden der Reihen, um sie zu verbinden. So wird die Ebene zu einer einzigen elektrischen Leitung und zugleich zu einem stabilen Rahmen; beim 4x4x4 macht ein Draht an beiden Enden die Ebene noch stabiler.
4. Ebene testen: Verbinde die Kathodenleitung mit GND, ohne die Ebene aus der Schablone zu nehmen, und tippe jedes Anodenbein über einen 220-Ω-Widerstand mit 5 V an. Leuchtet eine LED nicht, tausche sie jetzt aus.
5. Weitere Ebenen bauen: Fertige auf die gleiche Weise insgesamt 3 (oder 4) Ebenen. Die Kathodenbeine sollen in jeder Ebene in dieselbe Richtung zeigen, damit die Säulen genau übereinanderliegen.
6. Ebenen verbinden: Lass eine Ebene in der Schablone und richte die nächste auf den Abstandshaltern genau darüber aus. Biege an der Spitze jedes nach oben zeigenden Anodenbeins der unteren LEDs einen kleinen 2-mm-Knick, damit das Bein am Gehäuse der oberen LED vorbeiläuft und an deren Anodenbein anliegt. Löte zuerst die vier Ecken, prüfe die Ausrichtung und verlöte dann die restlichen Säulen.
7. Ebenenleitungen herausführen: Löte an die Kathodenleitung jeder Ebene einen Draht und führe ihn an einer Seite des Würfels nach unten. Diese Drähte dürfen sich gegenseitig und die Säulen nicht berühren; lass einige Millimeter Abstand.
8. Auf die Grundplatte setzen: Dreh den Würfel um; die freien Anodenbeine der zuletzt angelöteten Ebene zeigen jetzt nach unten, und diese Ebene wird zur Ebene direkt über der Grundplatte, also zur untersten Ebene (z = 0). Stecke die Beine und Ebenendrähte durch eine Lochrasterplatine, verlöte sie und setze die Säulenwiderstände neben jede Säule.

Ebenen mit Transistoren schalten

Ein Säulenpin versorgt immer nur eine LED, doch wenn eine Ebene eingeschaltet ist, fließt der Strom aller LEDs dieser Ebene über dieselbe Kathodenleitung nach GND zurück. Beim 3x3x3-Würfel sind das 9 LEDs × 12,7 mA ≈ 115 mA, beim 4x4x4-Würfel mit 74HC595 16 LEDs × 5 mA ≈ 80 mA. Für einen Pin des Arduino Uno werden 20 mA empfohlen, absolutes Maximum sind 40 mA; eine Ebenenleitung darfst du also nicht direkt an einen Pin hängen. Die Lösung ist ein NPN-Transistor unter jeder Ebene: Kollektor an die Ebenenleitung, Emitter an GND und Basis über einen Widerstand an einen Arduino-Pin. Geht der Pin auf HIGH, gerät der Transistor in die Sättigung und zieht die Ebene auf GND. Damit der Transistor voll durchschaltet, wählst du einen Basisstrom von etwa 1/10 bis 1/20 des Kollektorstroms: Für 115 mA brauchst du 6–12 mA, und (5 V − 0,7 V) / 470 Ω ≈ 9 mA liegt genau in diesem Bereich. Details findest du im Artikel Was ist ein Transistor?, die Pinbelegungen im Transistor-Tool.

Widerstände berechnen: Säulen- und Basiswiderstand

Der Säulenwiderstand ist das einzige Bauteil, das den LED-Strom begrenzt, und jede Säule bekommt einen. Einen Widerstand pro LED brauchst du nicht, weil in einer Säule immer nur eine LED gleichzeitig leuchtet. Die Formel stammt aus dem ohmschen Gesetz: R = (VVersorgung − VLED − VCE(sat)) / ILED. Bei 5 V Versorgung, einer roten LED mit 2,0 V Flussspannung und einem Transistor, der in der Sättigung etwa 0,2 V verliert, ergibt sich für 12 mA R = (5 − 2,0 − 0,2) / 0,012 ≈ 233 Ω. Der nächste Normwert, 220 Ω, lässt etwa 12,7 mA durch die LED fließen. Bei einer blauen LED mit 3,1 V liefert derselbe 220-Ω-Widerstand etwa 7,7 mA, was im Multiplexbetrieb noch gut sichtbar ist.

Beim Würfel mit 74HC595 wählen wir bewusst größere Widerstände: Über den VCC- oder GND-Pin dieses Chips dürfen insgesamt höchstens 70 mA fließen, und bei eingeschalteter Ebene können alle acht Ausgänge gleichzeitig leuchten. 8 × 5,5 mA ≈ 44 mA lassen einen sicheren Abstand. Der mittlere LED-Strom, der die wahrgenommene Helligkeit bestimmt, ergibt sich aus dem Momentanstrom geteilt durch die Anzahl der Ebenen: 12,7 / 3 ≈ 4,2 mA beim 3x3x3 und 5,5 / 4 ≈ 1,4 mA beim 4x4x4. Moderne, effiziente LEDs sind bei diesen Strömen in Innenräumen gut zu sehen, in einem sehr hellen Raum kann ein 4x4x4-Würfel aber etwas schwach wirken. Mit den Werten deiner eigenen LED rechnest du am einfachsten mit den Tools LED-Vorwiderstand und LED-Spannungen.

Schaltplan des 3x3x3-LED-Würfels

Arduino-Code für den 3x3x3-LED-Würfel: Animationen mit Arrays

Jedes Bild der Animation wird als eine Zahl pro Ebene gespeichert. Eine 3x3x3-Ebene hat 9 LEDs, also genügt ein 9-Bit-Wert; wir speichern ihn als uint16_t, und Bit c steht für Säule c. Die Bilder landen mit PROGMEM im Flash-Speicher, deshalb füllen selbst Animationen mit Hunderten von Bildern die 2 KB RAM des Uno nicht. Der folgende Code braucht keine zusätzliche Bibliothek.

1// 3x3x3 LED küp: katman çoklama ve dizilerle animasyon / 3x3x3 LED cube: layer multiplexing and array animations
2const byte colPins[9]   = {2, 3, 4, 5, 6, 7, 8, 9, 10};   // sütun anotları, 220 ohm ile / column anodes via 220 ohm
3const byte layerPins[3] = {A0, A1, A2};                     // alt, orta, üst katman transistörü / bottom, middle, top layer transistor
4
5// Her kare 3 katman, her katman 9 bit: bit c = sütun c (c = y*3 + x)
6// Each frame has 3 layers of 9 bits: bit c = column c (c = y*3 + x)
7const uint16_t frames[][3] PROGMEM = {
8  {0b111111111, 0b000000000, 0b000000000},  // 0: alt katman / bottom layer
9  {0b000000000, 0b111111111, 0b000000000},  // 1: orta katman / middle layer
10  {0b000000000, 0b000000000, 0b111111111},  // 2: üst katman / top layer
11  {0b000000000, 0b000010000, 0b000000000},  // 3: yalnız merkez / centre only
12  {0b111101111, 0b101000101, 0b111101111},  // 4: tel kafes, 12 kenar / wireframe, 12 edges
13  {0b010010010, 0b010010010, 0b010010010},  // 5: dönen düzlem, 1. konum / rotating plane, step 1
14  {0b100010001, 0b100010001, 0b100010001},  // 6: dönen düzlem, 2. konum / rotating plane, step 2
15  {0b000111000, 0b000111000, 0b000111000},  // 7: dönen düzlem, 3. konum / rotating plane, step 3
16  {0b001010100, 0b001010100, 0b001010100},  // 8: dönen düzlem, 4. konum / rotating plane, step 4
17  {0b111111111, 0b111111111, 0b111111111}   // 9: hepsi açık / all on
18};
19
20void setup() {
21  for (byte c = 0; c < 9; c++) pinMode(colPins[c], OUTPUT);
22  for (byte z = 0; z < 3; z++) pinMode(layerPins[z], OUTPUT);  // LOW: katmanlar kapalı / LOW: layers off
23}
24
25// Bir kareyi verilen süre boyunca katman katman tarar / scans one frame layer by layer for the given time
26void showFrame(byte f, unsigned int ms) {
27  unsigned long start = millis();
28  while (millis() - start < ms) {
29    for (byte z = 0; z < 3; z++) {
30      uint16_t bits = pgm_read_word(&frames[f][z]);         // katman verisini oku / read the layer data
31      for (byte c = 0; c < 9; c++) digitalWrite(colPins[c], bitRead(bits, c));
32      digitalWrite(layerPins[z], HIGH);                      // katmanı aç / layer on
33      delay(3);                                              // 3 ms göster / show for 3 ms
34      digitalWrite(layerPins[z], LOW);                       // sütunlar değişmeden önce kapat / off before the columns change
35    }
36  }
37}
38
39void loop() {
40  for (byte f = 0; f <= 4; f++) showFrame(f, 500);           // katmanlar, merkez, kafes / layers, centre, wireframe
41  for (byte turn = 0; turn < 4; turn++)                      // düzlemi 4 tur döndür / spin the plane 4 times
42    for (byte f = 5; f <= 8; f++) showFrame(f, 120);
43  showFrame(9, 800);                                         // hepsi açık / all on
44}

Das Herzstück des Codes ist die Funktion showFrame(). Für jede Ebene schreibt sie zuerst das Säulenmuster auf die Pins, schaltet dann nur den Transistor dieser Ebene für 3 ms ein und schaltet die Ebene wieder aus, bevor sich die Säulen ändern. Diese Reihenfolge ist wichtig: Änderst du die Säulen, während eine Ebene an ist, erscheint das Muster der vorherigen Ebene kurz auf der neuen Ebene, und es entsteht Ghosting (Geisterleuchten). bitRead(bits, c) liefert Bit c der Zahl als 0 oder 1, pgm_read_word() liest den 16-Bit-Wert aus dem Flash. loop() zeigt zuerst die Ebenen einzeln, dann die Mitte und die 12 Kanten des Würfels und dreht anschließend eine senkrechte Fläche durch vier Positionen, sodass ein Windrad-Effekt entsteht.

Eigene Animationen entwerfen

Um ein neues Bild zu zeichnen, schau von oben auf den Würfel und stell dir jede Ebene als 3x3-Kästchenpapier vor. Markiere die Säulen, die leuchten sollen, und schreib die Binärzahl nach 0b von links nach rechts, von Bit 8 bis Bit 0. Die vier Ecken sind zum Beispiel die Säulen 0, 2, 6 und 8, das ergibt 0b101000101. Schreibst du denselben Wert in alle drei Ebenen, entstehen senkrechte Stäbe an den vier Ecken; schreibst du ihn nur in die mittlere Ebene, schweben vier Punkte in der Luft. Wenn dir Binärzahlen neu sind, erklärt der Artikel Zahlensysteme und Bitoperationen das Prinzip ausführlich. Ein paar Techniken, die beim Programmieren helfen:

• Bits verschieben: Schiebst du den Wert einer Ebene beim 3x3x3 um 3 Bit, beim 4x4x4 um 4 Bit nach links, wandert das Muster eine Reihe nach hinten; überlaufende Bits entfernst du mit &, so entstehen Wellen und Lauftext.
• Ebenen kopieren: Kopierst du das Ebenen-Array eine Stufe nach unten oder oben, entstehen Regen, aufsteigende Blasen und Aufzug-Effekte.
• Zufall: Mit random() ausgewählte Voxel, die kurz aufblitzen, ergeben einen Sternenhimmel oder Funkeneffekt.
• Invertieren: Mit dem Operator ~ machst du aus einem Bild sein Negativ; schnelles Umschalten zwischen beiden ergibt ein blinkendes Highlight.

4x4x4-LED-Würfel: Erweiterung mit dem 74HC595

Ein 4x4x4-Würfel hat 16 Säulen und 4 Ebenen; direkt angesteuert braucht er 20 Pins, also alle Pins des Uno einschließlich D0 und D1. Steuerst du die Säulen stattdessen mit zwei kaskadierten 74HC595-Schieberegistern, kosten die 16 Säulen nur 3 Pins (Daten, Takt und Latch); mit 4 weiteren Pins für die Ebenen kommst du auf insgesamt 7 Pins. Der Ausgang Q7' (Pin 9) des ersten Chips geht an den DS-Eingang des zweiten, Takt- und Latch-Leitung teilen sich beide Chips. Die Säulen 0–7 (die vorderen zwei Reihen) hängen an Q0–Q7 des ersten Chips, die Säulen 8–15 (die hinteren zwei Reihen) am zweiten. Dasselbe Prinzip wächst auf 4 Chips für einen 5x5x5- und 8 Chips für einen 8x8x8-Würfel.

1// 4x4x4 LED küp: 2 adet 74HC595 (16 sütun) + 4 transistörlü katman / 4x4x4 LED cube: two 74HC595s (16 columns) + 4 transistor layers
2const byte DATA_PIN  = 11;                 // 74HC595 DS (14)
3const byte CLOCK_PIN = 13;                 // 74HC595 SH_CP (11)
4const byte LATCH_PIN = 10;                 // 74HC595 ST_CP (12)
5const byte layerPins[4] = {2, 3, 4, 5};    // alttan üste katman transistörleri, 470 ohm ile / layer transistors bottom to top, via 470 ohm
6
7uint16_t cube[4];                          // ekrandaki görüntü: katman başına 16 bit / current image: 16 bits per layer
8
9// Hazır kareler: bit c = sütun c (c = y*4 + x) / ready-made frames: bit c = column c (c = y*4 + x)
10const uint16_t frames[][4] PROGMEM = {
11  {0xFFFF, 0x0000, 0x0000, 0x0000},        // alt katman / bottom layer
12  {0x0000, 0xFFFF, 0x0000, 0x0000},
13  {0x0000, 0x0000, 0xFFFF, 0x0000},
14  {0x0000, 0x0000, 0x0000, 0xFFFF},        // üst katman / top layer
15  {0x9009, 0x0000, 0x0000, 0x9009},        // 8 köşe / 8 corners
16  {0xF99F, 0x9009, 0x9009, 0xF99F},        // tel kafes / wireframe
17  {0x0000, 0x0660, 0x0660, 0x0000}         // içteki 2x2x2 küp / inner 2x2x2 cube
18};
19const byte FRAME_COUNT = sizeof(frames) / sizeof(frames[0]);
20
21void write16(uint16_t v) {                 // 16 biti iki entegreye gönder / send 16 bits to both chips
22  digitalWrite(LATCH_PIN, LOW);
23  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, highByte(v));  // önce uzaktaki entegre / far chip first
24  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, lowByte(v));
25  digitalWrite(LATCH_PIN, HIGH);           // çıkışlara aktar / copy to the outputs
26}
27
28void refresh() {                           // her 2 ms'de sıradaki katmana geç / move to the next layer every 2 ms
29  static byte z = 0;
30  static unsigned long last = 0;
31  if (micros() - last < 2000) return;
32  last = micros();
33  digitalWrite(layerPins[z], LOW);         // eski katmanı kapat / old layer off
34  z = (z + 1) % 4;
35  write16(cube[z]);                        // yeni katmanın sütunları / columns of the new layer
36  digitalWrite(layerPins[z], HIGH);        // yeni katmanı aç / new layer on
37}
38
39void holdFor(unsigned int ms) {            // beklerken küpü yenilemeye devam et / keep refreshing while waiting
40  unsigned long start = millis();
41  while (millis() - start < ms) refresh();
42}
43
44void clearCube() {
45  for (byte z = 0; z < 4; z++) cube[z] = 0;
46}
47
48void setVoxel(byte x, byte y, byte z) {    // tek LED yak, x/y/z = 0..3 / light one LED, x/y/z = 0..3
49  bitSet(cube[z], y * 4 + x);
50}
51
52void loadFrame(byte f) {                   // PROGMEM'deki kareyi yükle / load a frame from PROGMEM
53  for (byte z = 0; z < 4; z++) cube[z] = pgm_read_word(&frames[f][z]);
54}
55
56void sweep() {                             // dikey düzlemi x ekseninde kaydır / sweep a vertical plane along x
57  for (byte x = 0; x < 4; x++) {
58    clearCube();
59    for (byte y = 0; y < 4; y++)
60      for (byte z = 0; z < 4; z++) setVoxel(x, y, z);
61    holdFor(150);
62  }
63}
64
65void rain(byte steps) {                    // yağmur: damlalar yukarıdan düşer / rain: drops fall from the top
66  clearCube();
67  for (byte s = 0; s < steps; s++) {
68    for (byte z = 0; z < 3; z++) cube[z] = cube[z + 1];   // her şeyi bir kat indir / move everything down a layer
69    cube[3] = bit(random(16)) | bit(random(16));         // üstte 1-2 yeni damla / 1-2 new drops on top
70    holdFor(120);
71  }
72}
73
74void setup() {
75  pinMode(DATA_PIN, OUTPUT);
76  pinMode(CLOCK_PIN, OUTPUT);
77  pinMode(LATCH_PIN, OUTPUT);
78  for (byte z = 0; z < 4; z++) pinMode(layerPins[z], OUTPUT);
79  randomSeed(analogRead(A0));              // boştaki A0'dan rastgele tohum / random seed from the unconnected A0
80}
81
82void loop() {
83  for (byte f = 0; f < FRAME_COUNT; f++) {
84    loadFrame(f);
85    holdFor(500);
86  }
87  for (byte i = 0; i < 3; i++) sweep();
88  rain(80);
89}

In dieser Version läuft das Abtasten in der Funktion refresh() nicht blockierend: Bei jedem Aufruf prüft sie mit micros(), ob 2 ms vergangen sind; falls ja, schaltet sie die alte Ebene aus, schickt die 16 Bit der neuen Ebene an die beiden Chips und schaltet die neue Ebene ein. So ändert der Animationscode nur das Array cube[] und muss sich nicht um das Auffrischen kümmern. holdFor() ruft während des Wartens weiter refresh() auf, deshalb solltest du nirgendwo im Programm ein langes delay() verwenden. Mit setVoxel(x, y, z) schaltest du eine einzelne LED über ihre Koordinaten ein; sweep() schiebt damit eine senkrechte Fläche durch den Würfel, rain() kopiert die Ebenen jeweils eine Stufe nach unten und setzt oben zufällige Tropfen. Den Unterschied zwischen delay() und millis() erklärt millis() und delay(), wie du das Abtasten in einen Timer-Interrupt verlagerst, zeigt Arduino-Interrupts.

LED-Würfel mit dem ESP32

Die Pins des ESP32 liefern 3,3 V. Das reicht nicht, um blaue und weiße LEDs mit etwa 3 V Flussspannung direkt anzusteuern; nach dem Spannungsabfall an Widerstand und Transistor bleibt kaum etwas übrig. Am saubersten ist es daher, die Säulen beim ESP32 über einen mit 5 V versorgten 74HCT595 anzusteuern: Die HCT-Familie erkennt schon 2 V als HIGH und liest die 3,3-V-Signale problemlos, während die LEDs aus 5 V gespeist werden. An die Basis der Ebenentransistoren kommen wieder 470 Ω; (3,3 − 0,7) / 470 ≈ 5,5 mA reichen für 80 mA Ebenenstrom. Der 4x4x4-Code oben lässt sich auf dem ESP32 unverändert kompilieren; du musst nur die Pin-Konstanten auf die Werte aus der Tabelle ändern (23, 18, 5 sowie 25, 26, 27, 32). Wenn du magst, wählst du die Animationen über das WLAN des ESP32 auch auf einer Webseite am Handy aus; zum Einstieg siehe Was ist der ESP32?.

LED-Würfel mit dem Raspberry Pi Pico und MicroPython

Auch der Pico ist ein 3,3-V-Board, und in der Standardeinstellung liefern seine Pins nur wenige Milliampere; deshalb nutzt du dieselbe Schaltung mit 74HCT595. Versorge die Chips und LEDs über VBUS (Pin 40), an dem die 5 V vom USB anliegen. In MicroPython werden die 16 Bit per Hardware-SPI gesendet: GP18 (SCK) und GP19 (MOSI) von SPI0 treiben Takt- und Datenleitung, GP17 den Latch. Der Code folgt derselben Logik: show() tastet ein Bild für die angegebene Zeit Ebene für Ebene ab, und beim Regeneffekt schiebt das Listen-Slicing (cube[1:]) jede Ebene eine Stufe nach unten. Für Einrichtung und erste Schritte siehe Was ist der Raspberry Pi Pico?.

1# Pico + 2 adet 74HCT595 ile 4x4x4 LED küp / 4x4x4 LED cube with a Pico + two 74HCT595s
2from machine import Pin, SPI
3import time
4import random
5
6# GP18 = SCK -> SH_CP, GP19 = MOSI -> DS; GP16 (MISO) boş kalır / GP16 (MISO) stays unconnected
7spi = SPI(0, baudrate=1000000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
8latch = Pin(17, Pin.OUT, value=0)                                # ST_CP
9layers = [Pin(n, Pin.OUT, value=0) for n in (10, 11, 12, 13)]    # alttan üste, 470 ohm ile / bottom to top, via 470 ohm
10
11def write16(v):
12    latch.value(0)
13    spi.write(bytes((v >> 8, v & 0xFF)))    # önce uzaktaki entegre / far chip first
14    latch.value(1)                          # çıkışlara aktar / copy to the outputs
15
16def show(frame, ms):
17    # kareyi ms boyunca katman katman tara / scan the frame layer by layer for ms
18    end = time.ticks_add(time.ticks_ms(), ms)
19    while time.ticks_diff(end, time.ticks_ms()) > 0:
20        for z in range(4):
21            write16(frame[z])
22            layers[z].value(1)              # katmanı aç / layer on
23            time.sleep_us(2000)
24            layers[z].value(0)              # sütunlar değişmeden kapat / off before the columns change
25
26FRAMES = [
27    [0x9009, 0x0000, 0x0000, 0x9009],       # 8 köşe / 8 corners
28    [0xF99F, 0x9009, 0x9009, 0xF99F],       # tel kafes / wireframe
29    [0x0000, 0x0660, 0x0660, 0x0000],       # içteki küp / inner cube
30]
31
32while True:
33    for f in FRAMES:
34        show(f, 600)
35    cube = [0, 0, 0, 0]
36    for _ in range(60):                     # yağmur: her şey bir kat iner / rain: everything drops a layer
37        drop = (1 << random.getrandbits(4)) | (1 << random.getrandbits(4))
38        cube = cube[1:] + [drop]
39        show(cube, 120)

Größere Würfel: 5x5x5 und 8x8x8

Mit der Größe des Würfels wachsen zwei Probleme. Das erste ist der Strom: Ein 8x8x8-Würfel hat 64 LEDs pro Ebene, bei 10 mA pro LED sind das 640 mA Ebenenstrom; das ist keine Aufgabe mehr für einen kleinen TO-92-Transistor, sondern für einen Logic-Level-MOSFET. Das zweite ist die Abtastzeit: Um mit 8 Ebenen 100 Hz zu halten, bleiben pro Ebene 1,25 ms, und pro Ebene müssen 64 Bit (8 Byte) gesendet werden; shiftOut() ist dafür zu langsam, Hardware-SPI ist Pflicht. Außerdem leuchtet jede LED nur 1/8 der Zeit, die Helligkeit sinkt also; große Würfel brauchen stärkere Säulentreiber und statt USB ein externes 5-V-Netzteil (siehe Arduino mit Strom versorgen). Deshalb sollte dein erster Würfel ein 3x3x3 oder 4x4x4 sein; so beherrschst du die Technik, bevor du 512 LEDs lötest.

Alternative: farbiger LED-Würfel mit WS2812B

Möchtest du statt eines einfarbigen Würfels die Farbe jeder LED einzeln wählen, kannst du adressierbare LEDs wie die WS2812B verwenden. Jede dieser LEDs hat ihren eigenen Treiberchip, daher brauchst du weder Multiplexing noch Transistoren oder Säulenwiderstände: Die 64 LEDs werden mit 5 V, GND und einer Datenleitung in Reihe verkettet und über einen einzigen Pin angesteuert. Für einen Würfel nimmt man adressierbare 5-mm-LEDs mit 4 Beinen (etwa PL9823 oder APA106) oder Stücke eines WS2812B-Streifens. Der Preis ist der Strom: etwa 60 mA pro LED bei vollem Weiß, also 3,8 A für 64 LEDs. Nutze deshalb ein 5-V-Netzteil mit 4 A, setze einen 1000-µF-Kondensator an die Versorgung und einen 330-Ω-Widerstand in die Datenleitung und begrenze die Helligkeit per Software. Der Code verwendet die Bibliothek Adafruit NeoPixel.

1// WS2812B ile 4x4x4 RGB LED küp / 4x4x4 RGB LED cube with WS2812B
2#include <Adafruit_NeoPixel.h>
3
4const byte DATA_PIN = 6;                   // 330 ohm ile ilk LED'in DIN ucuna / to the first LED's DIN via 330 ohm
5const byte N = 4;
6Adafruit_NeoPixel cube(N * N * N, DATA_PIN, NEO_GRB + NEO_KHZ800);
7
8uint16_t idx(byte x, byte y, byte z) {     // koordinattan zincirdeki sıraya / coordinate to position in the chain
9  return z * 16 + y * 4 + x;               // düz (zikzaksız) kablolama varsayılır / assumes straight, non-zigzag wiring
10}
11
12void setup() {
13  cube.begin();
14  cube.setBrightness(40);                  // parlaklığı ve akımı sınırla (0-255) / limit brightness and current (0-255)
15}
16
17void loop() {
18  static uint16_t hue = 0;
19  for (byte z = 0; z < N; z++)
20    for (byte y = 0; y < N; y++)
21      for (byte x = 0; x < N; x++)         // her katman farklı tonda / each layer gets a different hue
22        cube.setPixelColor(idx(x, y, z), cube.gamma32(cube.ColorHSV(hue + z * 8192U)));
23  cube.show();
24  hue += 256;                              // gökkuşağını kaydır / shift the rainbow
25  delay(20);
26}

Die Funktion idx() im Code rechnet eine x-, y-, z-Koordinate in die Position in der Kette um und geht davon aus, dass du jede Reihe in derselben Richtung verdrahtet hast. Hast du die Verkabelung im Zickzack verlegt, musst du in ungeraden Reihen 3 − x statt x verwenden. Manche adressierbaren 5-mm-LEDs erwarten die Farben in RGB-Reihenfolge; siehst du Grün statt Rot, ändere NEO_GRB in NEO_RGB. setBrightness(40) senkt die Helligkeit auf etwa 16 %, sodass der Strom selbst im ungünstigsten Fall bei etwa 0,6 A bleibt.

Projektideen mit dem LED-Würfel

• Würfel, der zur Musik tanzt: Erhöhe die Zahl der leuchtenden Ebenen je nach Lautstärke, die du mit einem Schallsensor misst, und bau so einen dreidimensionalen Equalizer.
• 3D-Snake: Steuere die Schlange im 4x4x4-Würfel mit einem Joystick und einem Taster über drei Achsen; weitere Spielideen findest du unter Arduino-Spieleprojekte.
• Spielwürfel: Drückst du einen Taster, wirbeln die Voxel kurz durcheinander, und der Würfel zeigt eine Zahl von 1 bis 6 als Punktmuster.
• Projekt für Schule oder Wettbewerb: Erkläre die Trägheit des Auges, indem du die Ebenenzeit mit einem Potentiometer verlängerst und den Moment zeigst, in dem das Flimmern beginnt; weitere Ideen unter Projektideen für Wettbewerbe.
• Animation per Handy wählen: Jeder Buchstabe, den du über ein HC-05-Bluetooth-Modul sendest, startet eine andere Animation.
• Bunte Nachtlampe: Richte auf einem WS2812B-Würfel langsame Farbübergänge ein; mit einem ESP32 steuerst du die Effekte über WLED vom Handy aus.

Häufige Fehler und ihre Lösungen

Der LED-Würfel ist eines der seltenen Projekte, die Löten, Transistoren, Widerstandsberechnung, Multiplexing und Bitoperationen in einem vermitteln. Fang mit einem 3x3x3 an, und wenn Code und Animationslogik sitzen, steig mit dem 74HC595 auf einen 4x4x4 um oder auf WS2812B, wenn du Farbe willst. Möchtest du das Prinzip, LEDs nacheinander zu schalten, zuerst an einer geraden Reihe ausprobieren, ist Arduino-Lauflicht und Knight Rider ein gutes Aufwärmen. In der BlueGrays-App findest du Projekte mit Lauflicht, Knight Rider, WS2812B-Animationen und LED-Matrizen, jeweils mit Schaltplan und Code Schritt für Schritt.