LEGO Weihnachtsbaum mit blinkenden LEDs – Do-It-Yourself

Weihnachten kommt mit großen Schritten auf uns zu. An den Fenstern und in den Straßen werden immer mehr Weihnachtslichter aufgehängt und gerade am Abend blinkt und leuchtet es überall. Auch Zuhause werden so langsam die Weihnachtsbäume aufgestellt und geschmückt. Da habe ich mir gedacht, es wäre doch cool einen LEGO Weihnachtsbaum mit blinkenden Lichtern zu haben.

Der LEGO Weihnachtsbaum war schnell gefunden, denn ich hatte noch einen LEGO 40338 Weihnachtsbaum, der endlich eine tiefer Bestimmungen bekommen sollte.

Aufgebaut war er schnell, doch wie bekomme ich die kleinen Kristalle und den Weihnachtsstern zum Blinken, mhhh?

Wie ich das ganze umgesetzt habe, möchte ich Euch gerne in diesem Artikel vorstellen.

Zielsetzung und Vorgaben

Ein paar kleine Rahmenbedingungen sollte der blinkende LEGO Weihnachtsbaum erfüllen. Dazu gehört:

• Jedes Licht soll separat ein-/ausschaltbar sein.
• Stromversorgung soll über USB-Stecker bzw. 5V erfolgen.
• Kein Kleben. Die transparenten, farbigen Kristalle sollen austauschbar sein, aber trotzdem relativ fest steckenbleiben.

Fragestellungen und Erkenntnisse

Erkenntnisse aus dem LEGO Lichtschwert mit LED weiterverwenden

Wenn Ihr Euch erinnern könnt, hatte ich letztes Jahr ja schon einige Erkenntnisse mit dem beleuchteten LEGO Lichtschwert von Obi-Wan sammeln können.

In dem Artikel LEGO Lichtschwert mit LED zum Leuchten bringen – Do It Yourself Anleitung wurden die folgenden Fragen beantwortet:

• Welche LED verwenden?
• Welche Kabel verwenden?
• Wie ist das mit dem Vorwiderstand?
• Welche Lochgröße ist sinnvoll?
• Wie war das noch mit dem „Ohmschen Gesetz“?

Damit sind schonmal ein paar wichtige Lösungen vorhanden, die ich auch beim blinkenden Weihnachtsbaum weiterverwenden und erweitern kann.

Was könnte ich verwenden um jede LED individuell leuchten zu lassen?

Der LEGO Weihnachtsbaum hat insgesamt zwölf Kristalle auf den Ästen und einen Weihnachtsstern auf der Spitze. Wie schaffe ich es also jede LED anzusteuern und separat ein- und auszuschalten?

Ich habe mich daher für einen ESP32 NodeMCU entschieden. Es handelt sich hier um einen kleinen, programmierbaren Microcontroller. Ich selbst nutze den von AZ-Delivery, aber es gibt auch andere Hersteller die einen ESP32 NodeMCU anbieten.

Der ESP32 NodeMCU basiert auf den (vielleicht) bekannten Arduinos, allerdings hat er ein paar Zusatzfunktionen, die es auch erlauben würden den ESP32 in ein WLAN einzubinden oder sogar einen kleinen Webserver darauf laufen zu lassen.

Ihr könnt über C++ Programme die unterschiedlichen Pins und Funktionen ansteuern, d.h. ich könnte an bestimmte PINs eine LED anschließen und sie leuchten lassen. Also haben, wir damit schonmal im Groben die Voraussetzung erfüllt, die LEDs separat anzusteuern.

Eine weitere Voraussetzung ist ebenfalls erfüllt, denn wir können ein Micro-USB Kabel an den ESP32 NodeMCU anschließen und ihn mit Strom versorgen.

Eine kleine Herausforderung entsteht allerdings trotzdem, denn die unterschiedlichen PINs auch GPIOs genannt nutzen 3,3V und sollten bzgl. Stromstärke nicht überlastet werden. Eine Ausnahme stellt der 5V Pin dar, aber den gibt es halt nur einmal.

Genau der Punkt führt uns zur nächsten Fragestellung.

Wie versorge ich die LED mit Strom ohne GPIOs zu zerstören?

Wir verwenden die gleiche SMD-LED 0805, wie auch bei Obi-Wans LED Lichtschwert. Aus den Experimenten wissen wir ja,

• die SMD-LED bei 3,4V und 20mA am hellsten leuchtet
• 5V über USB als Spannung genutzt wird
• damit einen Vorwiderstand von 100 Ohm benötigt.

Die „Parameter“ für die LED möchte ich nicht ändern. Es würde zwar grundsätzlich mit weniger Spannung (V) und einem anderen Vorwiderstand zur Kontrolle der Stromstärke (A) gehen, aber die LED wäre dunkler und ich möchte auch nur wenige Milliampere (mA) and den GPIOs anlegen. Sie sollen ja eigentlich nur „steuern“ und keine „großen“ Lasten versorgen.

Hier kommen Transistoren ins Spiel und zwar als Schalter.

Transistor als Schalter

Ich möchte Euch nicht im Detail erklären, wie ein Transistor aufgebaut ist, wie es mit der Stromverstärkung auf sich hat oder welche unterschiedlichen Transistor-Schaltungen es gibt. Ich möchte Euch lediglich erklären, wie ich einen Transistor als Schalter verwende, um einerseits die LED zu aktivieren und andererseits meine GPIOs nicht zu zerstören.

Das schöne am Transistor ist, dass ich durch Anlegen einer kleinen Spannung und wenig Stromstärke, einen größeren Strom und eine andere Spannung „einschalten“ kann.

Dafür hat ein Transistor, hier ein NPN-Transistor Typ BC547B, drei Beinchen. Den Collector (1), die Basis (2) und den Emitter (3).

Erst wenn man an der Basis (2) Strom anlegt, wird der Stromkreis vom Collector (1) zum Emitter (3) geöffnet und die LED kann leuchten.

Dann schauen wir uns mal die Schaltung an.

Es gibt im Grunde zwei Strecken.

Strecke 1 (3,3V): Ihr verbindet die Basis (2) des Transistors mit einem Basis-Widerstand und diesen wiederum mit einem GPIO vom ESP32 NodeMCU. Durch den 10k Ohm Widerstand wird die Stromstärke auf unter 1mA begrenzt. Somit besteht keine Gefahr den GPIO zu grillen.

Strecke 2 (5V): Ihr verbindet die 5V Spannungsversorgung, z.B. 5V Pin vom ESP32, mit der SMD-LED und einem Vorwiderstand in Reihe. Der Vorwiderstand wird mit dem Collector (1) des Transistors verbunden.

Jetzt müsst Ihr nur noch den Emitter (3) mit dem Minuspol (GND) verbinden. Diese dient als gemeinsame Erdung für beide Strecken.

Stellt Ihr also jetzt den GPIO auf „AN“, dann „öffnet“ der Transistor und die SMD LED leuchtet.

So viel zum Transistor als Schalter.

Wie auf einen Schritt mehrere LED zum Leuchten bringen?

Im Grunde habe ich mit dem ESP32 und der Transistor-Schaltung alles um den LEGO Weihnachtsbaum blinken zu lassen. Allerdings wäre es etwas aufwändig mehrere LEDs auf einen Schritt leuchten zu lassen. Des Weitere wollte ich nicht alle GPIOs belegen um LEDs anzusteuern.

Also kam mir in den Sinn einen Port-Extender zu verwenden. Der MCP23017 ist ein kleiner Baustein mit dem ihr zusätzliche 16 GPIOs bekommt, die Ihr nur mit Hilfe von zwei GPOIs am ESP32 NodeMCU und dem sogenannten I²C-Bus ansteuern könnt.

Die zusätzlichen GPIOs, die man bekommt, heißen im obigen Bild GPA0 – GPA7 und GPB0 – GPB7. Dabei müsst Ihr die Belegung am eigentlichen Chip beachten. Des Weiteren ist es wichtig zu wissen, dass es zwei „Register“ gibt, über welche die Ausgänge „angewählt“ werden. Dazu aber mehr wenn wir uns den eigentlichen Programm-Code ansehen.

Der MCP23017 wird hier mit 3,3V betrieben.

Die Ports „SCL“ und „SDA“ sind für den I²C-Bus zuständig und empfangen die „Befehle“. Hier wird sozusagen gesendet „Schalte LED 1, 5 und 7“ an, und das in (quasi) einem Schritt.

Auf dem Schaubild seht Ihr noch die Ports A0, A1 und A2. Je nachdem ob Ihr sie mit dem Pluspol (3,3V) oder dem Minuspol (GND) verbindet, wird die Adresse festgelegt, mit dem Ihr den MCP23017 finden und Befehle geben könnt. In meinem Beispiel sind alle drei Pins mit dem Minuspol (GND) verbunden, d.h. der Chip hat die binäre Adresse „0100000“ oder als HEX-Adresse „0x20“. Das merken wir uns für das spätere Programm.

In der folgenden Tabelle seht Ihr auf welche Adresse der Chip hört und Befehle empfängt.

Durch die Adressen könnte man auch mehrere unterschiedliche MCP23017 ansteuern.

Mit der Nutzung des Port-Extenders könntet man theoretisch auch einen kleineren Microcontroller als den ESP32 NodeMCU verwenden.

So, das waren ein paar Fragestellungen und Herausforderungen. Dann kann es ja mit dem praktischen Teil losgehen. 🙂

Do-It-Yourself Anleitung

So jetzt geht es ans Eingemachte.

Das Material

Für meinen Aufbau habe ich folgendes Material verwendet.

Das Werkzeug

Hier eine kleine Übersicht zum Werkzeug.

Schritt 1: SMD LED vorbereiten

Wie schon beim LED Lichtschwert verwende ich die kalt-weißen SMD-LED 0805. Für eine schlanke Verkabelung nutze ich Micro-Litze in rot und schwarz.

Rot steht für die Anode (+) und schwarz für die Kathode (-) der LED. Erkennbar sind sie an dem grünen Dreieck/Pfeil in der Mitte der LED. Die Dreiecksspitze zeigt auf die Kathode und die breite Seite auf die Anode.

Achtet auf ausreichende Länge der Litzen. Ich habe ca. 20cm verwendet.

Schritt 2: Löcher in die Halterungen bohren

Damit die einzelnen Kristalle beleuchtet werden können, müssen wir kleine Löscher in die „Halterungen“ (plate 1×2 with 1 knob; 6092586) bohren.

Dafür verwende ich einen kleinen Handbohrer. Für das Loch verwende ich einen Bohrer mit 1mm Durchmesser.

Am Ende könnt Ihr beide Seiten des Loches noch entgraten. Dafür verwendet Ihr einfach einen etwas größeren Bohrer mit 1,5mm Durchmesser.

Schritt 3: LED einbauen

Durch das Loch zieht Ihr die schwarze und rote Micro-Litze, welche Ihr zuvor an die SMD-LED gelötet habt.

Den Kristall steckt Ihr im Anschluss darauf. Leider sitzt er nicht so stabil wie der transparente Stab beim Lichtschwert, aber dennoch einigermaßen fest.

Das ganze macht Ihr 13-mal.

Schritt 4: Die Schaltung

Bevor Ihr jetzt wild drauf lötet, solltet Ihr Euch Gedanken machen, wie die unterschiedlichen Bauteile auf der Lochrasterplatine verteilt werden und wie sie zusammengeschaltet werden.

Im Folgenden seht Ihr ein Schaubild, wie die Schaltung aussieht. Im Schaubild sind aus Platzgründen nicht alle LED eingezeichnet, aber Ihr müsst eigentlich nur den Teil mit der LED, dem Transistor und den zwei Widerständen noch ein paar mal kopieren. Im Bild sind die Anschlüsse GPA1 bis GPA6 nur angedeutet. Aber ich denke das Prinzip sollte damit erklärt sein.

Die gepunkteten Linien sind Leiterbahnen aus Kupferdraht und verlaufen auf der Unterseite der Lochrasterplatine.

Ihr solltet Euch auch Gedanken dazu machen, welche Pins vom MCP23017 mit was verbunden werden. Hier eine Tabelle wie ich es gelöst habe.

Schritt 5: Platine bestücken und die Bauteile verlöten

Das Bestücken der Platine, das verlegen der Leiterbahnen & Kabel und das Löten sind der anstrengenste Teil des ganzen. Als grundlegenden Tipp kann ich Euch nur mitgeben, dass Ihr Euch Zeit last, lieber doppelt prüft ob die Teile richtig liegen und Pausen macht.

Begonnen habe ich mit den Sockelleisten für den ESP32 NodeMCU. Die Leisten werden mit der Platine verlötet und der ESP32 NodeMCU aufgesteckt. Dadurch habe ich die Möglichkeit den Microcontroller für andere Projekte weiterzuverwenden oder auszutauschen.

Wenn Ihr die Sockelleisten anlötet, lasst vorerst die Stellen frei, welche auf der Unterseite die Leiterbahnen aus Kupferdraht berühren.

Als nächstes habe ich den Sockel für den Port-Extender platziert und verlötet.

Im Anschluss kamen dann die Widerstände und Transistoren dran. Das ist die fummeligste Arbeit, da Ihr an bestimmten Stellen mehrere Elemente beim Löten verbinden müsst. Damit Euch die Bauteile nicht aus der Platine fallen, könnt Ihr diese auf der Oberseite auch mit einem Klebestreifen fixieren.

Als nächsten Schritt habe ich die Leiterbahnen aus Kupferdraht verlegt. Um sie einigermaßen gerade zu bekommen, könnt Ihr den Draht zwischen zwei Zangen auseinander ziehen. Die Leiterbahnen habe ich nur an Kontaktstellen zu anderen Elementen oder an abgewinkelten Stellen verlötet.

So und ganz zum Schluß kommen die unterschiedlichen Kabel dran. Die Kabel habe ich von oben in die Löcher gesteckt und auf der Unterseite dann verlötet.

Schritt 6: Den Baum schmücken

Jetzt könnt Ihr die Lichter auf dem Weihnachtsbaum befestigen.

Beim Stern auf der Baumspitze, schiebt Ihr die LED mittig hinein. Um die Löcher auf beiden Seiten zu verschließen, habe ich transparente Noppen verwendet.

Damit ist der Elektronikteil fertig und ihr könntet das Programm auf den ESP32 spielen, an ein und der Baum blinkt.

Schritt 7: Kästchen und Stromversorgung

Damit die Platine nicht so frei im Raum schwirrt, habe ich noch ein kleines Kästchen aus LEGO gebaut. Ich denke da seid Ihr wahrscheinlich kreativer als ich.

Das schöne an der Micro-Litze, dass sie wunderbar zwischen den Noppen/Bausteinen entlang geführt werden kann.

Links unten könnt Ihr sehen, wie der ESP32 mit einem Micro-USB-Kabel verbunden wurde. Darüber wird später auch der Programm-Code aufgespielt und es wird auch der Anschluss an die Stromversorgung sein.

Der Programm-Code

Damit der Weihnachtsbaum auch wirklich bringt, muss ein Programm auf den ESP32 NodeMCU installiert werden. Dies macht Ihr z.B. mit der Arduino IDE oder Visual Studio Code mit PlattformIO.

Was macht das Programm?

Nachdem Ihr den ESP32 mit Hilfe des USB-Kabels mit Strom versorgt (z.B. Handy-Ladegerät) wird er und das Programm gestartet. Nach der Initalisierung void setup() {...}, beginnt eine unendliche Schleife void loop() {...}. Am Anfang der Schleife werden alle Lichter für 5 Sekunden eingeschaltet, danach geht es in eine weitere Schleife, die 100-mal läuft. In jedem der 100 Durchläufe wird eine zufällige Kombination an Lichtern eingeschaltet. Danach geht es wieder zum Anfang der Endlosschleife und alle Lichter werden für 5 Sekunden eingeschaltet, usw.

Was geschieht bei der Initialisierung?

Die Initialisierung erfolgt in der Funktion void setup().

Zunächst legt Ihr mit Wire.begin(26,25);fest welche GPIOs am ESP32 für den I²C-Bus zum MCP23017 zuständig sind.

Mit Wire.beginTransmission(0x20); startet Ihr eine Übertragung zum MCP23017. Die „0x20“ ist dabei die Adresse des Port-Extenders.

Per Wire.write(...); werden die Befehle übermittelt. In unserem Fall werden die Ports GPA0-7 und GPB0-7 als Ausgänge definiert.

Mit Wire.endTransmission(); wird die Übertragung beendet.

Die Endlosschleife / die Hautpfunktion

Nachdem die Initialisierung erfolgt ist, geht es in die Hauptfunktion void loop(). Es handelt sich dabei um eine Endlosschleife.

Zu Beginn werden Variablen definiert. Eine besondere Funktion haben dabei die Variablen randoma, randomb, randompause. Sie werden verwendet um Zufallszahlen zu speichern. Diese sollen zufällig  bestimmen, welche Ports eingeschaltet werden und wie lange die Pause bis zum nächsten Lichterwechsel ist.

Mit dem folgenden Code-Teil werden erstmal die GPA0-7 und GPB0-7 auf 0 bzw. LOW gesetzt. Dafür wird erst die Verbindung an der Adresse 0x20 aufgebaut. Dann wird dem Port-Extender mitgeteilt, dass etwas mit den GPA Ports geschehen soll. Dann wird per „0x0“ gesagt: „Alles aus“. Dann wird die Übertragung beendet. Danach passiert das gleiche mit den GPB Ports des MCP.

Wire.beginTransmission(0x20);
Wire.write(0x12); 
Wire.write(0x0); 
Wire.endTransmission(); 
Wire.beginTransmission(0x20); 
Wire.write(0x13); 
Wire.write(0x0); 
Wire.endTransmission();

Dann passiert genau das Gegenteil und alle Lichter werden für 5 Sekunden eingeschaltet. Also, die Übertragung wird an der Adresse 0x20 begonnen. Dann werden die GPA Ports ausgewählt und mit Wire.write(0xFF); werden alle 8 Ports „eingeschaltet“. Die Übertragung wird beendet und es geht mit den GPB Ports weiter. Am Ende wird 5 Sekunden gewartet.

Wire.beginTransmission(0x20); 
Wire.write(0x12); // GPA ansprechen 
Wire.write(0xFF); // Alle GPA Ports auf 1/HIGH setzen. 
Wire.endTransmission(); 
Wire.beginTransmission(0x20); 
Wire.write(0x13); // GPB ansprechen 
Wire.write(0xFF); // Alle GPB Ports auf 1/HIGH setzen. 
Wire.endTransmission(); 
delay(5000); // 5 Sekunden warten

Dann geht es in die zweite Schleife mit den 100 Durchläufen.

for (int i = 0; i < 100; i++) { 
  randomSeed(13); // initialisiert den Zufallszahlengenerator 
  randoma = random(0,255); // Zufallszahl zwischen 0 und 255 erzeugen. 
  randomb = random(0,31); // Zufallszahl zwischen 0 und 31 erzeugen. 
  randompause = random(1,5) * 1000; // Zufallszahl zwischen 1 und 5 um Anzahl Sekunden für Pause 
  Wire.beginTransmission(0x20); 
  Wire.write(0x12); // GPA 
  Wire.write(randoma); // Aktiviere GPA Ports die der Zufallszahl entsprechen 
  Wire.endTransmission(); 
  Wire.beginTransmission(0x20); 
  Wire.write(0x13); // GPB 
  Wire.write(randomb); // Aktiviere GPA Ports die der Zufallszahl entsprechen Wire.endTransmission(); 
  delay(randompause); // Pause zwischen 1 und 5 Sekunden 
}

Besonders zu erwähnen ist hier, dass über den random(x,y); Befehl die Zufallszahlen für die zu aktivierenden Ports und die Pause zwischen den Durchgängen erzeugt wird.

Für die GPA Ports vom ersten Register wird eine Zufallszahl von 0 bis 255 ermittelt. Dabei muss man verstehen, dass wir 8 GPA Ports haben (GPA0 bis GPA7). Jeder Port kann den Wert 0 oder 1 annehmen. Bei 1 leuchtet die LED, bei 0 leuchtet sie nicht.

Wenn wir uns jetzt GPA7 bis GPA0 in Reihe vorstellen ergibt dies eine 8-stellige binäre Zahl, 0000 0000 bis 1111 1111. Das entspricht einem dezimalen Zahlenbereich von 0 bis 255. Also je nachdem welche Wert die Variablen „randoma“ oder „randomb“ annehmen, leuchten entsprechende LED. Hier ein paar Beispiele.

Bei „randomb“ haben wir nur die den Zahlenbereich 0 bis 31, da ja auch nur GPB0 bis GPB4 mit einer LED verbunden sind.

So ich hoffe das war einigermaßen verständlich.

Der vollständige Programm-Code

Im folgenden findet Ihr den vollständigen Programm-Code. Entweder Ihr übernehmt ihn per Copy & Paste in die Arduino IDE oder Ihr ladet Euch die Datei herunter.

Programm-Code hier herunterladen

#include <Arduino.h>
#include "Wire.h"

void setup() {
  Wire.begin(26,25); // i2c GPIOs bei ESP32 auswählen
  Serial.begin(9600);
  Serial.println("Starte i2c-test"); 
  Wire.beginTransmission(0x20); // Übertragung zu MCP23017 mit i2c-Adresse 0x20 HEX beginnen.
  Wire.write(0x00); // Register 1 für GPAxx Ports auswählen
  Wire.write(0x00); // Alle Ports vom Register 1 als Ausgänge (GPA0 - GPA7) festlegen.
  Wire.endTransmission(); // Übertragung beenden
  Wire.beginTransmission(0x20); // Übertragung zu MCP23017 mit i2c-Adresse 0x20 HEX beginnen.
  Wire.write(0x01); // Register 2 für GPBxx Ports auswählen
  Wire.write(0x00); // Alle Ports vom Register 2 als Ausgänge (GPB0 - GPB7) festlegen.
  Wire.endTransmission(); // Übertragung beenden
}

void loop() {
  byte error;
  int pause;
  pause = 500;
  long randoma, randomb, randompause; // Variablen für Zufallszahlen

  // 0x20 ist die Adresse des MCP23017
  Serial.println("Versuche MCP23017 mit Adresse 0x20 zu kontaktieren"); 

  Wire.beginTransmission(0x20);
  error = Wire.endTransmission();
  Serial.println(error); // Fehlerausgabe an serieller Schnittstelle.

  Wire.beginTransmission(0x20);
  Wire.write(0x12); // Adresse für die A Ports
  Wire.write(0x0);  // Alle GPA Ports auf 0/LOW setzen
  Wire.endTransmission();
  Wire.beginTransmission(0x20);
  Wire.write(0x13); // Adresse für die B Ports
  Wire.write(0x0);  // Alle GPB Ports auf 0/LOW setzen
  Wire.endTransmission();

  delay(pause);

  Wire.beginTransmission(0x20);
  Wire.write(0x12); // GPA ansprechen
  Wire.write(0xFF); // Alle GPA Ports auf 1/HIGH setzen.
  Wire.endTransmission();
  Wire.beginTransmission(0x20);
  Wire.write(0x13); // GPB ansprechen
  Wire.write(0xFF); // Alle GPB Ports auf 1/HIGH setzen.
  Wire.endTransmission();
  delay(5000); // 5 Sekunden warten

  for (int i = 0; i < 100; i++)
  {
    randomSeed(13); // initialisiert den Zufallszahlengenerator
    randoma = random(0,255); // Zufallszahl zwischen 0 und 255 erzeugen.
    randomb = random(0,31); // Zufallszahl zwischen 0 und 31 erzeugen.
    randompause = random(1,5) * 1000; // Zufallszahl zwischen 1 und 5 um Anzahl Sekunden für Pause
    Wire.beginTransmission(0x20);
    Wire.write(0x12); // GPA
    Wire.write(randoma); // Aktiviere GPA Ports die der Zufallszahl entsprechen
    Wire.endTransmission();
    Wire.beginTransmission(0x20);
    Wire.write(0x13); // GPB
    Wire.write(randomb); // Aktiviere GPA Ports die der Zufallszahl entsprechen
    Wire.endTransmission();
    delay(randompause); // Pause zwischen 1 und 5 Sekunden
  }
}

Endlich blinkt der LEGO Weihnachtsbaum

Und so sieht der fertige LEGO Weihnachtsbaum mit den leuchtenden und blinkenden LED aus. Ich denke er ist ganz gut geworden.

Was könnte man sonst noch machen?

Ein paar letzte Überlegungen was man noch ändern oder erweitern könnte.

• Einen kleinen Webserver auf den ESP32 installieren und den LEGO Weihnachtsbaum per Smartphone steuern.
• Die Verkabelung zu den Lichtern schöner verlegen.
• Platine verkleinern
• Einen Schalter einbauen.
• Das Ein-/Ausschalten per Tageszeit, Bewegungsmelder oder vielleicht Helligkeit steuern.

Also Ihr seht da geht noch mehr 😉

So, ich hoffe die Beschreibung gefällt Euch und sie ist einigermaßen verständlich. Ich wünsche Euch viel Spaß beim Nachbauen.