LED-Tisch » Ein einsteigergerechtes Arduino-Projekt für die Ausbildung in Schule und Beruf
Veröffentlicht: 12.01.2024 | Lesedauer: 6 Minuten
Mikrocontroller sind aus unserem Leben nicht mehr wegzudenken. Sie übernehmen die unterschiedlichsten Steuerungsaufgaben und sind von der Kaffeemaschine bis zum Computer in fast jedem modernen Gerät zu finden.
Doch wie können diese zum Teil recht kleinen und unscheinbaren Bauteile ihre Aufgaben so zuverlässig erledigen? Noch wichtiger: Wie können identische Mikrocontroller unterschiedliche Aufgaben erfüllen und woher wissen die Steuercomputer, was sie wie zu tun haben?
Um alle diese Fragen beantworten zu können, haben sich praktische Anwendungsbeispiele sowohl in der Schule als auch in der Berufsausbildung bestens bewährt. Ideal sind dabei Projekte, die für Jugendliche zudem auch noch technisch überschaubar, nützlich und „cool“ sind. Denn dann sind das Engagement für den Nachbau und der Erfolg beim haptischen Lernen quasi vorprogrammiert.
Unser programmierbarer LED-Tisch erfüllt genau diese Voraussetzungen und deshalb wollen wir Ihnen das Projekt von unserem Technikheld Simon Bäumer etwas genauer vorstellen.
Der Grundgedanke war, dass ein handelsüblicher Beistelltisch, der bei namhaften Möbel-Discountern für wenig Geld erhältlich ist, modifiziert und optisch aufgepeppt wird. Dazu wird auf der Oberseite eine diffuse Plexiglasplatte montiert, unter der 25 LEDs leuchten. Der Clou an der Konstruktion ist, dass die LEDs nicht dauerhaft leuchten, sondern das Raster aus 5 x 5 LEDs unterschiedliche Lichtmuster erzeugen kann.
Die jeweiligen Lichtmuster werden mithilfe eines Arduino Uno erzeugt, der nach Lust und Laune individuell programmiert werden kann.
Somit werden beim Aufbau des LED-Tischs nicht nur mechanische Fertigkeiten gefördert. Auch das Verständnis für Elektronik und vorhandene Lötkenntnisse werden vertieft. Und letztendlich muss auch der Controller noch programmiert werden. Doch unabhängig davon ist das Projekt ideal für Einsteiger geeignet.
Übrigens: Für alle, die noch keine Erfahrungen mit den programmierbaren Steuercomputern der Arduino-Familie sammeln konnten, haben wir einen leicht verständlichen Ratgeber erstellt.
Schritt 1: Basis für den Tisch
Ein einfacher Beistelltisch mit Hochglanzlack ist die Basis für unseren Umbau. Solche Tische, die schon für unter 10 € zu bekommen sind, bestehen meist nur aus einer dünnen MDF (Pressspanplatte) auf der Ober- und Unterseite. In der Mitte sorgt ein Wabenmuster aus Pappe für die notwendige Stabilität. So lässt sich der Tisch auch mit einem scharfen Taschen- oder Cutter-Messer leicht bearbeiten. Spezielle Holzwerkzeuge sind nicht notwendig.
Schneiden Sie ein Loch mit exakt 40 cm x 40 cm in den Tisch (siehe Abbildung).
Als Ersatz für die Tischplatte wird zum Abschluss eine diffuse Plexiglasscheibe aus dem Baumarkt eingesetzt. Diese sollte nach Möglichkeit dieselbe Farbe wie der Tisch aufweisen. Drücken Sie seitlich die Pappe ein wenig ein, um den Arduino und die Zusatzplatine darin platzieren zu können.
Für den LED Tisch werden 25 LEDs in verschiedenen Farben (Grün, Rot, Blau, Gelb) verwendet. Damit Sie später schöne Lichteffekte bekommen und die LEDs sich nicht gegenseitig überblenden, wird ein Holzgestell gebaut. Die Bestandteile des Holzgestells werden aus Sperrholzplatten (4 mm) gefertigt.
Schritt 2: Bau des Holzgestells
Das Holzgestell muss 25 gleich große und quadratische Fächer aufweisen, in denen später die LEDs untergebracht werden. Die seitliche Größe des Holzgestells sollte mit 40 x 40 cm so bemessen sein, dass es exakt und ohne zu klemmen in die angefertigte Öffnung im Tisch passt.
Die Höhe des Gestells richtet sich nach der verwendeten Plexiglasplatte. Die aufgesetzte Platte muss später bündig mit der Umrandung auf der Oberseite des Tisches abschließen.
Bei korrekter Anfertigung sorgt das Holzgestell auch für die erforderliche Belastbarkeit der Plexiglasplatte, wenn schwere Gegenstände darauf abgestellt werden.
Sägen Sie in die mittleren 8 Spanten jeweils vier bis zur Mitte reichende 4 mm Schlitze, um die Spanten beim Aufbau des Gitters ineinander stecken zu können. Danach wird der äußere Rahmen angeklebt. Im fertigen Gitter müssen an der Unterseite noch Kerben eingeschnitten werden, damit die Kabel der LED-Matrix nicht gequetscht werden.
Unser Praxistipp: Holzzuschnitt im Baumarkt
Viele Baumärkte mit einer Holzabteilung bieten oft einen Zuschnitt-Service an. Erfahrene Mitarbeiter sägen dann die Holzteile exakt rechtwinklig und mit den richtigen Abmessungen zu. Meist können bei diesem Arbeitsschritt auch die Einkerbungen für das Zusammenstecken angefertigt werden. Falls nicht, lassen sich die Nuten leicht mit einer Handsäge herausarbeiten.
Schritt 3: Planen der LED-Matrix
Um die gewünschten Lichtmuster erzeugen zu können, ist es erforderlich, die 25 LEDs einzeln ansteuern zu können.
Um nicht jede LED mit separaten Anschlussleitungen versehen zu müssen, wird mit einer Matrix gearbeitet. In diesem Fall sind für die 25 LEDs lediglich 10 Leitungen erforderlich.
An den fünf senkrechten Leitungen (Rot) für die Spalten A - E wird die Plus-Spannung geschaltet und die waagerechten Leitungen (Blau) für die Reihen F - J werden an Masse geschaltet.
Beispiel zur Ansteuerung einer LED
Wenn beispielsweise die LED 17 leuchten soll, muss an der Leitung „B“ eine Plusspannung anliegen und die Leitung „I“ muss auf Masse (Minus-Potential) geschaltet werden.
Doch Vorsicht, wenn diagonal benachbarte LEDs wie beispielsweise die LED 13 und die LED 17 gleichzeitig leuchten sollen. Dazu muss die Plusspannung an den Leitungen „B“ und „C“ anliegen. Zudem müssen die beiden Leitungen „H“ und „I“ auf Masse geschaltet sein. In diesem Fall würden neben den LEDs 13 und 17 auch die LEDs 12 und 18 mit leuchten. Dies muss später beim Programmieren der gewünschten Lichtmuster berücksichtigt werden.
Unser Praxistipp: LED-Auswahl und Vorwiderstand
Bei der Wahl der LEDs stehen Ihnen viele Möglichkeiten offen. In der Praxis haben sich bedrahtete LEDs in unterschiedlichen Farben und Formen bestens bewährt, da sich die erforderlichen Drähte leicht anlöten lassen. Wichtig, achten Sie bei der LED-Auswahl auch auf den Öffnungswinkel des Lichtkegels. Je größer der ist, desto gleichmäßiger ist die Ausleuchtung des Feldes auf der Plexiglasplatte.
Je nachdem, welche LEDs zum Einsatz kommen und nach der Höhe der genutzten Betriebsspannung sind geeignete Vorwiderstände (R1 bis R25) zu verwenden. Die Berechnung von LED-Vorwiderständen haben wir in einem separaten Ratgeber ausführlich erklärt. Bitte verwenden Sie lediglich Standard-LEDs und keine lichtstarken HighPower-LEDs, die zum Betrieb spezielle Konstantstrom-Netzteile benötigen.
Schritt 4: Anfertigen der LED-Matrix
Jetzt müssen die LEDs zu einem Netz verkabelt werden. Als Schablone zum Absägen der Kabel dient das Holzgitter. Alle Plusleitungen führen von oben nach unten und alle Minusleitungen von links nach rechts. Die Kabelstränge werden später weiter zum Arduino bzw. zur Zusatzplatine geführt. Die benötigten Vorwiderstände werden zwischen der Plusleitung und der LED eingebaut.
Die Lichteffekte erzeugen wir mit dem Arduino. Dabei sind der Fantasie keine Grenzen gesetzt, alles was Ihnen gefällt ist machbar. Von einfachen Figuren bis hin zu sich dynamisch verändernden Mustern kann alles realisiert werden. Mittels Pulsweitenmodulation (PWM) können mehrere LEDs scheinbar gleichzeitig leuchten, obwohl in Wirklichkeit der Arduino nur einige hundert Mal pro Sekunde die einzelnen LEDs ein- und ausschaltet. Nach dem gleichen Prinzip werden die LEDs auch in der Helligkeit gedimmt.
Die 25 einzelnen LEDs werden gemeinsam von einem Arduino Uno (SMD Version) angesteuert. Da die Leistung des Arduinos nicht ausreicht, um die LEDs direkt anzusteuern, hat Simon eine kleine Platine entworfen, die Huckepack auf den Arduino gesteckt werden kann.
Der Vorteil der vorgestellten Platine ist, dass sie als Plug-and-Play Lösung mit einem Handgriff vom Arduino abgesteckt werden kann. Der Arduino lässt sich dann auch für andere Projekte nutzen.
Wahlweise kann man sich so eine Platine selber entwerfen und ätzen (Einsteigersets gibt es zu kaufen) oder auch im Internet für wenig Geld nach Wunsch ätzen lassen. Alternativ dazu lassen sich die Leistungstransistoren aber auch ohne großen Aufwand auf einer Lochrasterplatine aufbauen. Dafür haben wir für Sie den Schaltplan der Zusatzplatine bereitgestellt.
Schaltplan der Zusatzplatine
Die Zusatzplatine ist mit zehn Leistungstransistoren bestückt, die als elektronische Schalter dienen. Die Funktion eines Transistors haben wir in unserem Ratgeber zum BC547 anschaulich erklärt. Fünf Transistoren (T6 bis T10) übernehmen die Schaltfunktion der Plusleitungen und fünf Transistoren (T1 bis T5) schalten die Minusleitungen. Der Arduino kann trotz seiner geringen Leistung die Transistoren problemlos steuern, welche wiederum die Spannungen und die Ströme für die LEDs schalten. Da die Transistoren ausreichend Strom liefern, ist es auch möglich mehrere LEDs pro Feld zu nutzen und so die Ausleuchtung innerhalb eines Feldes zu optimieren. Gleichzeitig kann die Spannungsversorgung der Zusatzplatine (DCin) auch den Arduino mit versorgen.
Schauen wir uns die Eingänge und die Ausgänge der aufzubauenden Platine etwas genauer an. Zur Steuerung der Transistoren werden die Arduino Ausgänge D2 bis D6 sowie die Ausgänge D8 bis D12 genutzt. Je nachdem, ob vom Arduino ein Low-Pegel (0 V) oder ein High-Pegel (5 V) ausgegeben wird, leiten oder sperren die 10 Transistoren.
Wenn am Arduino alle 10 Ausgänge auf „Low“ gesetzt sind, schalten die Transistoren T6 bis T10 das Plus-Potential der Versorgungsspannung VCC auf die Ausgänge A bis E. Die LEDs werden aber noch nicht leuchten, da die Transistoren T1 bis T5 in diesem Fall gesperrt sind und die LEDs dadurch keinen Bezug zum Minus-Potential (GND) haben. Die LED-Stromkreise sind also noch nicht geschlossen. Erst wenn die Arduino-Ausgänge D2 bis D6 von „Low“ auf „High“ wechseln, schalten die Transistoren T1 bis T5 die LEDs an das Minus-Potential der Versorgungsspannung und schließen somit den Stromkreis. Die LEDs leuchten. Durch eine gezielte Kombination von „Low“ und „High“ Impulsen an den 10 Arduino-Ausgängen kann jede LED einzeln angesteuert werden. Die erforderliche Kombination für ein bestimmtes Leuchtmuster und der zeitliche Ablauf werden durch das Arduino-Programm definiert.
Wenn die Zusatzplatine erstellt wurde, muss sie mit den LEDs der Matrix und dem Arduino Steuercomputer verbunden werden. Auf der linken Seite des Schaltplans sind die Eingänge bzw. die erforderlichen Verbindungen zum Arduino zu erkennen. Die Anschlüsse der LED-Matrix sind auf der rechten Seite des Schaltplans zu finden. Zur besseren Übersicht haben wir sowohl die Klemmen im Schaltplan, als auch die Anschlussleitungen der LED-Matrix mit den Buchstaben A – J gekennzeichnet.
Auch wenn alles richtig aufgebaut, verlötet und zusammengesteckt wurde, werden die LEDs für den Tisch vorerst noch nicht leuchten. Denn der verwendete Arduino UNO ist ein Microcontroller, der erst noch programmiert werden muss. Verbinden Sie über ein USB-Kabel den Arduino mit Ihrem Computer und installieren Sie die Arduino Entwicklungsumgebung Arduino IDE (Integrated Development Environment). Diese steht auf der Arduino-Hersteller-Seite zum Download bereit.
Die Vorgehensweise zur Installation und Konfiguration haben wir ebenfalls in unserem Arduino-Ratgeber genau erklärt.
Wie wir gesehen haben, fungieren die Arduinopins D2 bis D6 und D8 bis D12 als Ausgänge. Deswegen werden sie im Programm (Sketch) mit dem Befehl pinMode(0, OUTPUT); als solche geschaltet. Zusätzlich wird anstelle der Pin-Nummer der Hardware die Bezeichnung “reihe_” bzw. “spalte_”verwendet. Das macht es einfacher, eine genaue LED anzusprechen. Es ist dem jeweiligen (ganzzahligen Variablen-) Namen ein Pin zugeordnet. Bei verschiedenfarbigen LED hilft es, die Farben [Rot: R, Blau: B, Grün: G] in der vorliegenden Abfolge im Kommentar aufzuzählen. Eine ausführliche Erklärung für die weiteren Steuerbefehle in den nachfolgenden Steuerprogrammen finden Sie auf der Arduino-Seite.
Für den einfachen Einstieg in die Programmierung haben wir die Steuerbefehle für zwei einfache Lichtabläufe aufgelistet:
Im folgenden Sketch werden alle LEDs einzeln ein- und wieder ausgeschaltet. Dabei erfolgt die Schaltung der LEDs zunächst innerhalb einer Reihe und nach einer kurzen Pause spaltenweise. Nach einer weiteren kurzen Pause beginnt der Ablauf erneut von vorne.
// Quellcode: LED-Tisch Conrad
int reihe_1 = 2; //R B R G B
int reihe_2 = 3; //G G B R G
int reihe_3 = 4; //B R B G R
int reihe_4 = 5; //R G R G B
int reihe_5 = 6; //G B G B R
int spalte_1 = 8;
int spalte_2 = 9;
int spalte_3 = 10;
int spalte_4 = 11;
int spalte_5 = 12;
int r,s;
void setup() {
pinMode(reihe_1, OUTPUT);
pinMode(reihe_2, OUTPUT);
pinMode(reihe_3, OUTPUT);
pinMode(reihe_4, OUTPUT);
pinMode(reihe_5, OUTPUT);
pinMode(spalte_1, OUTPUT);
pinMode(spalte_2, OUTPUT);
pinMode(spalte_3, OUTPUT);
pinMode(spalte_4, OUTPUT);
pinMode(spalte_5, OUTPUT);
}
void loop() {
// einzeln zeilenweise immer Spalte 1-5 an: 1,2,3,4,5,6,7,8,9,...
for (r=1; r<=5; r++){
for (s=1; s<=5; s++){
einzel_LED(r,s);
delay(1000);
alles_aus();
}}
delay(2000);
// einzeln spaltenweise immer Reihe 1-5 an: 1,6,11,16,21,2,7,12,...
for (int s=1; s<=5; s++){
for (int r=1; r<=5; r++){
einzel_LED(r,s);
delay(1000);
alles_aus();
}}
delay(2000);
}
void alles_aus () {
digitalWrite(reihe_1, LOW);
digitalWrite(reihe_2, LOW);
digitalWrite(reihe_3, LOW);
digitalWrite(reihe_4, LOW);
digitalWrite(reihe_5, LOW);
digitalWrite(spalte_1, HIGH);
digitalWrite(spalte_2, HIGH);
digitalWrite(spalte_3, HIGH);
digitalWrite(spalte_4, HIGH);
digitalWrite(spalte_5, HIGH);
}
void einzel_LED (int reihe, int spalte) {
// einzel_LED(r,s) schaltet LED in Reihe r und Spalte s ein
if (reihe == 1) digitalWrite(reihe_1, HIGH);
if (reihe == 2) digitalWrite(reihe_2, HIGH);
if (reihe == 3) digitalWrite(reihe_3, HIGH);
if (reihe == 4) digitalWrite(reihe_4, HIGH);
if (reihe == 5) digitalWrite(reihe_5, HIGH);
if (spalte == 1) digitalWrite(spalte_1, LOW);
if (spalte == 2) digitalWrite(spalte_2, LOW);
if (spalte == 3) digitalWrite(spalte_3, LOW);
if (spalte == 4) digitalWrite(spalte_4, LOW);
if (spalte == 5) digitalWrite(spalte_5, LOW);
}
Im folgenden Sketch werden zunächst alle 5 LEDs einer Reihe ein- und wieder ausgeschaltet. Dabei erfolgt die Schaltung der LEDs zunächst reihenweise und nach einer kurzen Pause spaltenweise. Nach einer weiteren kurzen Pause beginnt der Ablauf erneut von vorne.
// Quellcode: LED-Tisch Conrad
int reihe_1 = 2; //R B R G B
int reihe_2 = 3; //G G B R G
int reihe_3 = 4; //B R B G R
int reihe_4 = 5; //R G R G B
int reihe_5 = 6; //G B G B R
int spalte_1 = 8;
int spalte_2 = 9;
int spalte_3 = 10;
int spalte_4 = 11;
int spalte_5 = 12;
int r,s;
void setup() {
pinMode(reihe_1, OUTPUT);
pinMode(reihe_2, OUTPUT);
pinMode(reihe_3, OUTPUT);
pinMode(reihe_4, OUTPUT);
pinMode(reihe_5, OUTPUT);
pinMode(spalte_1, OUTPUT);
pinMode(spalte_2, OUTPUT);
pinMode(spalte_3, OUTPUT);
pinMode(spalte_4, OUTPUT);
pinMode(spalte_5, OUTPUT);
}
void loop() {
// ganze Zeile an: 1+2+3+4+5, 6+7+8+9+10, 11+12+....
for (r=1; r<=5; r++){
for (s=1; s<=5; s++){
einzel_LED(r,s);
delay(1000);
alles_aus();
}}
delay(2000);
// ganze Spalte an: 1+6+11+16+21, 2+7+12+17+22, 3+8+13...
for (s=1; s<=5; s++){
for (r=1; r<=5; r++){
einzel_LED(r,s);
}
delay(1000);
alles_aus();
}
delay(2000);
}
void alles_aus () {
digitalWrite(reihe_1, LOW);
digitalWrite(reihe_2, LOW);
digitalWrite(reihe_3, LOW);
digitalWrite(reihe_4, LOW);
digitalWrite(reihe_5, LOW);
digitalWrite(spalte_1, HIGH);
digitalWrite(spalte_2, HIGH);
digitalWrite(spalte_3, HIGH);
digitalWrite(spalte_4, HIGH);
digitalWrite(spalte_5, HIGH);
}
void einzel_LED (int reihe, int spalte) {
// einzel_LED(r,s) schaltet LED in Reihe r und Spalte s ein
if (reihe == 1) digitalWrite(reihe_1, HIGH);
if (reihe == 2) digitalWrite(reihe_2, HIGH);
if (reihe == 3) digitalWrite(reihe_3, HIGH);
if (reihe == 4) digitalWrite(reihe_4, HIGH);
if (reihe == 5) digitalWrite(reihe_5, HIGH);
if (spalte == 1) digitalWrite(spalte_1, LOW);
if (spalte == 2) digitalWrite(spalte_2, LOW);
if (spalte == 3) digitalWrite(spalte_3, LOW);
if (spalte == 4) digitalWrite(spalte_4, LOW);
if (spalte == 5) digitalWrite(spalte_5, LOW);
}
Die hier vorgestellten Codes können in der IDE-Software mit dem "Pfeilsymbol"-Button kompiliert und zum Arduino übertragen werden.
Wenn alle LEDs entsprechend dem Leuchtmuster leuchten, kann der Tisch fertiggestellt werden. Zunächst wird die LED-Matrix in die Tischöffnung gelegt und anhand des provisorisch eingesetzten Holzgestells optimal ausgerichtet. Die Befestigung erfolgt mit Hilfe von Heißkleber. Bevor das Holzgestell mit Holzleim festgeklebt wird, schaffen Sie unter dem verbliebenen Tischrand noch etwas Platz für die Zusatzplatine und den Arduino. Zudem muss noch an geeigneter Stelle eine Bohrung für das Stromversorgungskabel gesetzt werden. Zum Schluss wird dir Plexiglasplatte bündig aufgesetzt und mit Silikon abgedichtet.
Unser Tisch ist nun vollendet: Sobald der Arduino Strom bekommt, startet unsere Lichtershow. Natürlich lässt sich das Programm noch verändern, sodass wir die Lichteffekte regelmäßig austauschen können und es somit nicht langweilig wird. Als mögliche Upgrade-Funktionen bieten sich die Verwendung eines Mikrofons an, damit der Tisch auf Geräusche in der Umgebung reagieren kann oder die Verwendung von RGB LEDs in jeder Kammer – wir haben in unserem Modell darauf verzichtet, da der Verkabelungs- und Programmieraufwand dann deutlich größer wird. Ein spannendes Projekt ist es dennoch und die Variations-Möglichkeiten sind vielfältig.