*Ein Projekt von unserem Partner Elettronica IN - Italien

Hier stellen wir Ihnen ein Projekt vor, das Sie mit seinen Lichteffekten verzaubern wird, das in der Dunkelheit absolut faszinierend ist. Es basiert auf Leuchtdioden, genauer gesagt auf einer Matrix aus monochromen LEDs in drei Dimensionen, die zu einem Würfel angeordnet sind.

Led Matrix with Arduino Nano attached.
Die Matrix-Platine mit dem angeschlossenen Arduino Nano.

Es ist etwas Auffallendes und gleichzeitig Einfaches, das auch für die Jüngsten und diejenigen, die zum ersten Mal in die Elektronik einsteigen, erreichbar ist. Hinzu kommt, dass für die Realisierung keine Leiterplatte benötigt wird, da die Verbindungen der Würfelstruktur durch das Zusammenlöten der LED-Anschlüsse über eine Lochrasterplatine zur Steuereinheit gemacht werden.

Der LED-Würfel

Der Aufbau des Würfels besteht aus vier Ebenen von Leuchtdioden, die nach entsprechender Biegung der Anschlüsse und Anordnung in der richtigen Polarität zusammengelötet werden. Jede Ebene besteht aus 4 Reihen, die wiederum aus 4 LEDs bestehen, mit insgesamt 16 LEDs pro Ebene. Der Würfel besteht also aus insgesamt 64 LEDs. Dies alles wird von einer Arduino-Nano-Platine via Drahtverbindungen gesteuert, die den Strom führen und an eine Lochrasterplatine gelötet sind. Die Firmware bestimmt, welche LEDs im Würfel leuchten und welche nicht, und erzeugt Lichteffekte, mittels eine Multiplexsteuerung.

Unser Projekt benötigt deshalb die folgenden Elemente:

  • Arduino Nano-Platine;
  • 64 monochrome LED in der von Ihnen gewünschte Farbe;
  • Lochrasterplatine für den LED-Aufbau.

Wir laden das Arduino-Board mit einer von uns geschriebene Firmware, die wir Ihnen unten auf dieser Seite zur Verfügung stellen.

Der elektrische Anschlussplan ist in Abbildung 1 dargestellt. Er zeigt die Anschlüsse zwischen den Leitungen des Arduino Nano und den LEDs. Die Reihe und Anzahl der LEDs sind in Klammern angegeben: (1, 2) bedeutet zum Beispiel, dass der entsprechende Arduino-Pin an die zweite LED der Reihe 1 angeschlossen werden sollte; deshalb werden solche Zahlenpaare im Diagramm als Y, X bezeichnet.

Figure 1.jpg
Abbildung 1: Verbindungen zwischen Arduino I/O und LED-Reihen.

Die Ebenen mit jeweils 16 LEDs entsprechen der Bezeichnung Z und sind an die Pins A0 (A), A1 (B), A2 (C) und A3 (D) anzuschließen. Die ZBezeichnung ist mehr als passend, denn die Ebenen sind vertikal, also genau auf der Z-Achse angeordnet, während X und Y die Breite und Tiefe des Würfels sind.

Diese Zusammenhänge sind leichter zu verstehen, wenn man sich Abbildung 2 ansieht, die die räumliche Anordnung der LEDs zeigt und die Zusammenhänge der in Abbildung 1 gezeigten Zahlenpaare verdeutlicht.

Fig 2.jpg
Abbildung 2: Räumliche Anordnung der LEDs und Kennzeichnung der Verbindungen.

Die jeweils miteinander verbundenen Anoden der LEDs können vom Arduino I/O logisch hoch geschaltet werden, während die Kathoden der Dioden, die auf einer Ebene miteinander verbunden sind, zu den Leitungen A, B, C, D gehen, die auf logisch tief geschaltet werden können.

Was die Hardware betrifft, so ist jede vertikale Leitung mit einem I/O-Pad auf der Platine verbunden, sodass an jeden Pin 4 LEDs angeschlossen sind. Da unser Arduino Nano jedoch nur 14 digitale Pins hat, müssen wir 2 analoge Pins in digitale Pins umwandeln, sodass wir 16 digitale Pins erhalten (13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, A5, A4), mit denen wir die gewünschte Leitung ein- oder ausschalten können.

Durch eine vertikale Leitung auf logisch hoch zu schalten, und eine Ebene auf logisch Null, können wir genau bestimmen, welche LED leuchten muss.

Mit diesem Trick können wir das Projekt mit nur 20 E/A-Pins realisieren. Das wäre unmöglich gewesen, wenn wir an jeden Pin eine LED angeschlossen hätten. In diesem Fall hätten wir 64 Pins benötigt, und die eines kleinen Arduino Nano hätten eindeutig nicht ausgereicht.

Zusammenfassend lässt sich sagen, dass wir den Würfel in Ebenen (horizontal) und vertikale Leitungen (vertical) unterteilen, um jede LED unabhängig zu steuern. Jede LED, die sich auf derselben Ebene befindet, hat die Kathode (-) mit den anderen LEDs auf derselben horizontalen Ebene gemeinsam, während die Anoden (+) von den LEDs, die sich in derselben vertikalen Leitung befinden, miteinander verbunden sind.

Insgesamt gibt es 4 Pins zur Steuerung, mit denen die zu versorgende Ebene ausgewählt wird, und 16 Pins, die die einzelnen vertikalen Leitungen versorgen. Wenn wir eine bestimmte LED einschalten wollen, müssen wir sicherstellen, dass ihre Ebene auf logisch Null steht und die vertikale Leitung, zu der sie gehört, aktiv ist, d. h. auf logisch Eins steht.

Praktischer Aufbau

Nun, da wir an diesem Punkt angelangt sind, können wir beschreiben, wie wir unseren LED-Leuchtwürfel herstellen. Für diesen Vorgang benötigen wir neben den 64 Leuchtdioden (in unserem Fall wurden runde LEDs mit einem Durchmesser von 5 mm verwendet) und dem Arduino Nano, ein wenig 0,5-0,8 mm Massivdraht und flexibles Kabel für die Verbindungen zum Würfel und zwischen den LEDs.

Wir empfehlen Ihnen auch, ein quadratisches Stück Pappe (Pressholzplatte oder Sperrholz geringer Dicke, z. B. 3 mm) mit den Maßen 13×13 cm2 zu verwenden, das Ihnen als Schablone dient, die Sie für den Bau der Ebenen Ihres Würfels benötigen. Auf diesem Stück Pappe zeichnen Sie vier vertikalen Linien und ebenso vielen horizontalen Linien auf gleicher Distanz voneinander. Die Kreuzungen ergeben so 16 Punkte, die alle gleich weit von den benachbarten entfernt sind.

Mit einem spitzen Gegenstand kann man dann den Karton durchstechen, und zwar gerade so weit, dass eine LED mit der Oberseite nach unten hineinpasst (siehe Abbildung 3). Um die Ebenen zu erstellen, die den Würfel bilden, der jeweils aus 16 LEDs (in einer 4×4-Matrix) besteht, die in gleichem Abstand zueinander angeordnet sind, stecht man den Karton an allen Kreuzungspunkten durch, um den korrekten Abstand innerhalb der Konstruktion einzuhalten.

Figure 3.jpg
Abbildung 3: Die Pappschablone für die Abstände der LEDs.

In unserem Fall beträgt der Abstand zwischen jeder LED und der benachbarten LED 3 cm: ein Abstand, der unserer Meinung nach optimal ist, um eine kompakte und funktionelle Anzeige der vom Würfel gebildeten Figuren im Dunkeln zu erreichen.

Nehmen Sie also die perforierte Pappe und stecken Sie LEDs in die 16 Löcher, und zwar mit dem Kopf nach unten (d. h. mit dem "Kopf" in den Löchern). So können Sie die Anschlüsse umbiegen und die Bauteile in einer Ebene zusammenlöten; mit dieser Schablone können Sie nicht nur einen genauen Abstand zwischen den LEDs festlegen, sondern auch die Leuchtdioden fixieren, um das Löten zu erleichtern.

Biegen Sie dann die Kathodenanschlüsse im rechten Winkel und verlöten Sie sie miteinander: Biegen Sie sie dazu so, dass die von einer LED die von der nächsten berührt und mit ihr verlötet werden kann.

Wenn die Anschlüsse nicht lang genug sind, verlängern Sie sie mit einem Stückchen Draht und verbinden Sie dann die Drähte jeder Ebene, bis ein Gitter entstanden ist.

Die Anodenanschlüsse sollten zweimal gebogen werden, d. h. einmal im rechten Winkel und dann noch einmal im 90°-Winkel in einem Abstand von etwa 3 mm, gerade so weit, dass sie seitlich am Kopf der darunter liegenden LEDs vorbeigeführt werden können.

So können sie (eventuell mit einem Verlängerungsdraht) mit denen der nächsten Ebene verbunden werden.

Wenn Sie eine Ebene fertiggestellt haben, nehmen Sie sie aus der Pappschablone heraus und verdrahten Sie die anderen in ähnlicher Weise. Wenn Sie alle Ebenen auf die gleiche Weise produziert haben, müssen Sie vertikal die Anoden miteinander verbinden, um eine Art Käfig zu schaffen, der die Konstruktion stützt, stabilisiert und ihr eine Würfelform verleiht.

Jede der 16 LEDs auf einer Ebene muss mittels einer vertikalen Verbindung mit einem LED von einer anderen Ebene verbunden sein. Es gibt insgesamt 16 vertikale Leitungen (die erste LED auf jeder Ebene muss mit der auf der darunter liegenden Ebene übereinstimmen usw.).

Um das Ganze zu befestigen und zu verbinden, ist es ratsam, eine Lochrasterplatine der richtigen Größe zu verwenden: mindestens 10×10 cm2 . In ihre Löcher stecken Sie die Enden der vertikalen Leitungen des Würfels, 16 an der Zahl, und löten sie an den entsprechenden Pads. Danach verbinden Sie diese mit isoliertem Draht an die Pads des Arduino Nano-Boards entsprechend, was bereits erklärt wurde und unter Bezugnahme auf die Angaben in Abbildung 1 und Abbildung 2.

Eine detailliertere Darstellung des Aufbaus und der Anschlüsse ist im Schaltplan in Abbildung 4 zu sehen.

LED Matrix
Abbildung 4: Eine detailliertere Ansicht der Anschlüsse der LED-Matrix.

Wenn die Arbeit abgeschlossen ist, werden Sie etwas erhalten, wie es auf den Prototyp-Fotos in diesem Artikel zu sehen ist. Wie Sie sehen, wurden Dioden mit hoher Helligkeit in einem transparenten Gehäuse verwendet. Wenn Sie eine gleichmäßigere, wenn auch weniger intensive Lichtemission wünschen, können Sie herkömmliche LEDs (die typischerweise in einem Winkel von 120 bis 140 Grad emittieren) mit dem farbigen Gehäuse verwenden: zum Beispiel die in Abbildung 2 vorgeschlagenen grünen LEDs, ebenfalls mit einem Durchmesser von 5 mm.

Beachten Sie, dass die gesamte Schaltung mit Strom aus dem Micro-USBAnschluss des Arduino Nano-Boards betrieben wird. Die Stromversorgung, entweder aus dem angeschlossenen Computer oder, sobald der Sketch geladen ist, aus einem Netzteil mit Micro-USB-Anschluss, sollte mindestens 500 Milliampere liefern können.

Prototype-Finished.jpg
Der fertige Prototyp, ausgestattet mit einem Kunststoffgehäuse, der den Arduino Nano aufnimmt.

Firmware

Der Code, den wir uns ausgedacht haben, basiert auf dem bereits erwähnten Funktionsprinzip, d. h., dass der Arduino vier Pins steuern muss, die zur Auswahl der zu versorgenden Ebene verwendet werden, und damit die 16 Kathoden der betreffende Ebene. Wenn wir eine bestimmte LED der dreidimensionalen Matrix, aus der der Würfel besteht, einschalten wollen, müssen wir sicherstellen, dass ihre Ebene (d. h. diejenige, auf der sie sich physisch und elektrisch befindet...) mit Strom versorgt wird (d. h., dass ihre Kathoden von der Arduino Nano-Leitung zwischen A, B, C, D geerdet sind) und dass ihre vertikale Leitung aktiv ist; auf diese Weise schalten wir eine LED nach der anderen für jede Ebene ein.

Als Erstes haben wir die Pins deklariert (im Listing haben wir die E/A-Pins notiert, die wir in diesem Projekt benötigen). Das Deklarieren von Pins innerhalb des Codes wird verwendet, um einen bestimmten Pin auf dem Arduino zu konfigurieren und bestimmt, ob er als INPUT oder OUTPUT funktionieren soll.

In diesem Fall wurden die deklarierten Pins in vertikale Leitungen (Columns) und Ebenen (Layers) unterteilt, die aktiven Ausgänge sind, welche auf logisch Eins bzw. logisch Null geschaltet werden können (Listing 1).

/*
  4x4x4 LED Cube
  Connection Setup:
  Columns
  [(x,y)-Pin]
  (1,1)-13
  (1,2)-12
  (1,3)-11
  (1,4)-10
  (2,1)-9
  (2,2)-8
  (2,3)-7
  (2,4)-6
  (3,1)-5
  (3-2)-4
  (3-3)-3
  (3,4)-2
  (4,1)-1
  (4,2)-0
  (4,3)-A5
  (4,4)-A4
  Layers
  [layer-Pin]
  a-A0
  b-A1
  c-A2
  d-A3
*/
 
//initializing and declaring led columns
  int column[16]={13,12,11,10,9,8,7,6,5,4,3,2,1,0,A5,A4};
 
//initializing and declaring led layers
  int layer[4]={A3,A2,A1,A0};
 
  int time = 250;
 


Dann folgt das Setup, in dem die Firmware-Einstellungen definiert werden, und die for-Schleife, die die Grundlage für die Darstellung der Lichteffekte ist, weil sie den Wechsel der Logikpegel an den Pins des Arduino-Boards definiert, um die LEDs zu multiplexen. Schließlich befindet sich im Sketch die Schleife, die alle Routinen für die beabsichtigten Lichteffekte enthält (siehe Listing 2).

void loop()
{
  Serial.println(“sono nel loop”);
  turnEverythingOff();//turn all off
  flickerOn();
  turnEverythingOn();//turn all on
  delay(time);
  turnOnAndOffAllByLayerUpAndDownNotTimed();
  layerstompUpAndDown();
  turnOnAndOffAllByColumnSideways();
  delay(time);
  aroundEdgeDown();
  turnEverythingOff();
  randomflicker();
  randomRain();
  diagonalRectangle();
  goThroughAllLedsOneAtATime();
  propeller();
  spiralInAndOut();
  flickerOff();
  turnEverythingOff();
  delay(2000);
}

Innerhalb dieser Schleife befinden sich die einzelnen Funktionen, die den Lichteffekten entsprechen, von denen wir in Listing 3 die PropellerLichtkomposition (Animation) vorstellen, deren visueller Effekt darin besteht, die LEDs der Flächen nacheinander einzuschalten, sodass ein rotierendes Licht wie die Bewegung eines Propellers erscheint.

  /////////////////////////////////////propeller
void propeller()
{
  turnEverythingOff();
  int x = 90;
  for(int y = 4; y>0; y--)
  {
    for(int i = 0; i<6; i++)
    {
      //turn on layer
      digitalWrite(layer[y-1], 1);
      //a1
      turnColumnsOff();
      digitalWrite(column[0], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[15], 0);
      delay(x);
      //b1
      turnColumnsOff();
      digitalWrite(column[4], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[11], 0);
      delay(x);
      //c1
      turnColumnsOff();
      digitalWrite(column[6], 0);
      digitalWrite(column[7], 0);
      digitalWrite(column[8], 0);
      digitalWrite(column[9], 0);
      delay(x);
      //d1
      turnColumnsOff();
      digitalWrite(column[3], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[12], 0);
      delay(x);
      //d2
      turnColumnsOff();
      digitalWrite(column[2], 0);
      digitalWrite(column[6], 0);
      digitalWrite(column[9], 0);
      digitalWrite(column[13], 0);
      delay(x);
      //d3
      turnColumnsOff();
      digitalWrite(column[1], 0);
      digitalWrite(column[5], 0);
      digitalWrite(column[10], 0);
      digitalWrite(column[14], 0);
      delay(x);
    }
  }
  //d4
  turnColumnsOff();
  digitalWrite(column[0], 0);
  digitalWrite(column[5], 0);
  digitalWrite(column[10], 0);
  digitalWrite(column[15], 0);
  delay(x);
}

In der Schleife gibt es jeweils eine Funktion für eine der Lichteffekte.

Die Liste der Funktionen bzw. Animationen, die der LED-Würfel bietet, ist wie folgt:

  • turnEverythingOff();
  • flickerOn();
  • turnEverythingOn();
  • turnOnAndOffAllByLayerUpAndDownNotTi;
  • layerstompUpAndDown();
  • turnOnAndOffAllByColumnSideways();
  • aroundEdgeDown();
  • randomflicker();
  • randomRain();
  • diagonalRectangle();
  • goThroughAllLedsOneAtATime();
  • propeller();
  • spiralInAndOut();
  • flickerOff();

Am Ende der Schleife wird mit der Anweisung delay(2000) eine Verzögerung von 2 Sekunden eingefügt, bevor eine neue Sequenz ausgeführt wird.

Um den Sketch in Arduino zu installieren, müssen Sie natürlich das Arduino Nano-Board anschließen (ob es in der Würfelschaltung montiert ist, ist irrelevant...), dann die IDE starten, dann aus dem Menü Tools > Board das Arduino Nano-Board auswählen und dann den Sketch öffnen (File > Open), und dann beginnen, ihn in den Arduino zu laden, indem Sie auf die Schaltfläche Load klicken.

Schlussfolgerung

Der Vorteil dieses Projekts ist, dass Sie es nach Ihren Wünschen konfigurieren und neue Beleuchtungseffekte hinzufügen können. Um dies zu tun, müssen Sie allerdings einige Kenntnisse der programmiersprache “C” haben, die auf Arduino verwendet wird; machen Sie sich jedoch keine allzu großen Sorgen, denn selbst wenn Sie nur hier und da im Web suchen, werden Sie viele ähnliche Projekte finden, wo LEDs angesteuert werden, mit entsprechender Hardware-Komplexität.

Um den Sketch so zu konfigurieren, dass Sie mehr Leuchtdioden ansteuern können, müssen Sie nur den Code kopieren und in das BoardProgramm einfügen. Dann müssen Sie nur die Pin-Deklarationen im Code ändern oder die Verbindungen der Ebenen und Kanten auf dem Arduino ändern.

In diesem Sinne bleibt Ihnen nur noch, einander gute Arbeit zu wünschen und viel Spaß mit Ihrem Lichtwürfel zu haben.