Bi-Color LED Matrix mit dem Arduino

Inhalt

Einleitung

Der Arduino ist ein Microcontrollerboard, das auf dem ATmega328P basiert (Weitere Informartionen ) Er verfügt über 14 digitale Ein-/ bzw. Ausgänge, 6 analoge Eingänge, einen USB-Anschluss, einen Stromanschluss, einen 16 MHz Quartzkristall (zur Zeitbestimmung) und einen Reset-Knopf. Mit dem Arduino kann man LEDs, Motoren oder ähnliches anschließen und diverse Sensoren auslesen. Auch kleine LCD-Displays oder LED-Matrizen kann man ansteuren und Dinge auf ihnen anzeigen. Im Folgenden wird sich auf die 8x8 Bicolor LED Matrix von Adafruit bezogen, die man sich hier bestellen kann.[1]

Inbetriebnahme des Arduino

Um den Arduino in Betrieb zu nehmen ist lediglich ein USB-A auf USB-B Kabel nötig, welches auch mitgeliefert wurde. Um Programme für den Arduino zu schreiben und sie auf den Arduino zu überspielen, benötigt man die Arduino Software. Downloadlink: Windows, Mac, Linux Für die Projekte sind lediglich Grundkentnisse des Arduinos erforderlich.

Die LED-Matrix

Die LED-Matrix besteht aus ingesamt 128 LEDs, von denen 64 rot und 64 grün sind. Sie können abwechselnd oder zusammen leuchten, sodass die Farben rot, grün und gelb/orange dargestellt werden können. Wie zu erkennen ist, verfügt die Matrix lediglich über 24 Pins, das heißt, dass auf einen Pin mehr als fünf LEDs entfallen. Um dennoch alle LEDs korrekt anzusteuern, kommt das Backpack (auf diesem sitezt ein Microchip) ins Spiel. Mit einer Technik namens Multiplexing ist es möglich, mehrere Signale gebündelt zu übermittlen, um so die Übertragungsstrecke zu optimieren. Die Multiplexarbeit verrichten der Arduino und das Backpack, die als Sender und Empfänger die Signale erst bündeln und dann wieder aufspalten.

Hier sieht man, wie die Matrix immer wieder abgetastet wird, um in Hochfrequenz ein konstantes Bild zu kreieren

Zusammenbau

Damit alles korrekt funktioniert, ist es wichtig, dass das Backpack und die Matrix korrekt zusammengelötet sind. Falls es das erste mal Löten sein sollte, ist hier ein kleines Tutorial.

allignment

1.

Man nimmt nun die Matrix zur Hand, und steckt sie auf den Microcontroller. WICHTIG!!! In einer Ecke ist statt einem Quadrat ein Kreis. Auf diese Seite muss die Seite der Matrix, auf die der Text steht (siehe Bild).

2.

Jetzt dreht man die Matrix mit dem Chip auf der Rückseite um und lötet alle 24 Pins fest. Anschließend knipst man die langen Enden ab um die Matrix nacher besser auf einem Breadboard platzieren zu könnnen.

solder1 solder2 solder3

3.

Anschließend lötet man das "4-Pin-Stück" an die Platine. Damit das einfacher geht, steckt man dieses Stück zuvor mit den langen Pins in ein Breadboard und platziert dann die Matrix darauf. Nun lötet man die vier Pins fest.

4pin1 4pin2 4pin3

4.

Zuletzt muss die Matrix noch an den Arduino angeschlossen werden. Dafür benötigt man vier Jumper-Kabel, die man folgendermaßen verbindet:

Oberseite Matrix Unterseite Matrix Pin am Arduino
+ VCC 5V
- GND GND
D SDA A4
C SCL A5

Test

succes

Jetzt kann man die Matrix testen: Hierzu einfach den Test-Code herunterladen und ausführen. Die Matrix sollte nun den Text Du hast es geschafft! in grün, gelb und rot anzeigen. Anschließend wird ein grüner Smiley eingeblendet. ACHTUNG! Damit die Martix funktioniert, müssen zuerst die beiden Bibliotheken von Adafruit heruntergeladen werden: Adafruit GFX und Adafruit LED Backpack . Wie man diese korrekt installiert, siehe hier.

Programme mit der Matrix

Die Matrix kann, wie bereits gesehen, alles mögliche Anzeigen. Damit das "Backpack" die Befehle richtig umsetzt, muss man zuerst die erforderlichen Libraries importieren. Dies geschieht über der Befehl #include "Name_der_Library.h. In diesem Falle wären das Adafruit_GFX.h, Adafruit_LEDBackpack.h und Wire.h . Danach trägt man ein um welches LED-Zubehör es sich handelt: Adafruit_BicolorMatrix matrix = Adafruit_BicolorMatrix(); Im Setup startet man den seriellen Monitor mit dem Befehl Serial.begin(9600);. Optional kann man noch einen Log einfügen, der den Programmstart makiert. Beispiel: Serial.println("Programmstart");. Ganz wichtig ist die Eingabe der IC2-Adresse, was mit dem Befehl matrix.begin(0x70); durchgeführt wird. Dabei ist die Adresse immer 0x70 für die erste Matrix die verbunden wurd, sind zwei verbunden, hat die erste die Adresse 0x70 und die zweite 0x71 und so fort. Ist alles richtig konfiguriert, kann es mit dem Programmieren losgehen. Ein fertiges Schema kann hier heruntergeladen werden.

Die Lichtorgel

Dies ist keine Lichtorgel im eigentlichen Sinne, sondern lediglich eine Darstellung von Lichtabläufen, Formen und Farben. Man kann jedoch mit verschiedenen Befehlen, viele Effekte darstellen. Um etwas auf der Matrix anzuzeigen verwendet man den Befehl matrix.writeDisplay(); und um das was auf dem Bildschirm zu sehen ist zu entfernen, matrix.clear();. Wenn man die Matrix nicht "cleared" und erneut etwas "writed", dann wird es einfach auf das vorhandene projiziert. ACHTUNG! Führt man den Befehle matrix.writeDisplay(); nicht aus, wird nichts auf der Matrix geändert!

Einzelne Pixel

bitmap

Um einzelne Pixel zum Leuchten zu bringen, nutzt man den Befehl matrix.drawPixel(x,y, LED_COLOR);. X und Y ersetzt man dabei durch die entsprechenden Koordinaten. ACHTUNG! Die Koordianten beginnen bei (0;0) und enden bei (7;7). Um die Suche nach den richtigen Koordinaten zu vereinfachen, habe ich eine Übersicht (siehe Bild) hergestellt. COLOR steht für die Farbe, wobei die Werte YELLOW(für gelb/orange), GREEN(für grün) und RED(für rot) eingesetzt werden können. Alle matrix.drawPixel(x,y, LED_COLOR); Befehle, die vor einem matrix.writeDisplay(); Befehl stehen, werden simultan ausgeführt, möchte man eine Pause einbauen, muss man den Befehl delay(t in ms); mit einbauen. Falls komplexere Formen dargestellt werden Sollen, sollte man auf Bitmaps zurückgreifen.

Beispiel für einen roten Punkt bei (1;4): matrix.drawPixel(1,4, LED_RED);

Linien

Linien werden ähnlich wie Pixel programmiert. Ihr Befehl lautet matrix.drawLine(x1,y1, x2,y2, LED_COLOR);. Die Koordinaten (x1;y1) geben dabei den Startpunkt und (x2;y2) den Endpunkt der Linie an. So können die Linien beliebig lang und ausgerichtet sein. COLOR gibt wieder die Farbe (YELLOW,GREEN, oder RED) an. Alle Linien, die vor einem matrix.writeDisplay(); Befehl stehen, werden parallel eingeblendet. Baut man kleine Pausen mit ein, kann man einen Übergang etc. bauen.

Beispiel für eine Grüne Linie von (0;1) bis (7;1):matrix.drawLine(0,1, 7,1, LED_GREEN);

Rechtecke

rectangles

Es gibt zwei Arten von Rechtecken: Gefüllte und Leere.

Die Gefüllten können mit dem Befehl matrix.fillRect(x;y, l,b, LED_COLOR) dargestellt werden. X und Y stehen für den Startpunkt des Rechtecks, d. h. ab diesem Punkt breiten sich die Kanten in x und y-Richtung aus. L und B stehen für Länge und Breite des Rechtecks. Möchte man ein Quadrat anzeigen, müssen beide Werte gleich groß sein. COLOR steht wieder für die Farben (YELLOW,GREEN, oder RED). In dem man mehrere Befehle für Rechtecke vor einen matrix.writeDisplay(); Befehl schreibt, kann man mehrere Rechtecke gleichzeitig einblenden.

Beispiel für ein gelbes Rechteck, 5 lang und 6 breit ausgehend vom Punkt (1;1): matrix.fillRect(1,1, 5,6, LED_YELLOW);

Leere Rechtecke funktionieren nach dem gleichen Prinzip, nur das sie innen hohl sind. Ihr Befehl lautet matrix.drawRect(x,y, l,b, LED_COLOR); X und Y stehen für den Startpunkt des Rechtecks, d. h. ab diesem Punkt breiten sich die Kanten in x und y-Richtung aus. L und B stehen für Länge und Breite des Rechtecks. Möchte man ein Quadrat anzeigen, müssen beide Werte gleich groß sein. COLOR steht wieder für die Farben (YELLOW,GREEN, oder RED). Auch hier kann man mehrere Rechtecke kombinieren.

Beispiel für 4 Leere und 4 gefüllte Rechtecke ineinander, jeweils farbverschoben:

matrix.drawRect(0,0, 4,4, LED_GREEN);
matrix.drawRect(0,0, 4,4, LED_GREEN);
matrix.drawRect(0,4, 4,4, LED_RED);
matrix.drawRect(4,4, 4,4, LED_GREEN);
matrix.drawRect(4,0, 4,4, LED_RED);
matrix.fillRect(5,1, 2,2, LED_GREEN);
matrix.fillRect(1,1, 2,2, LED_RED);
matrix.fillRect(1,5, 2,2, LED_GREEN);
matrix.fillRect(5,5, 2,2, LED_RED);

Kreise

circles

Kreise verhalten sich ähnlich wie Rechtecke: Es gibt leere und gefüllte. Um sie zu positionieren gibt man den Mittelpunkt und den Radius an. Der Befehl für einen Kreis ohne Füllung lautet also matrix.drawCircle(x,y, r, LED_COLOR);. Die Koordinate (x;y)gibt den Mittelpunkt an und r den Radius. COLOR wie immer die Farbe. Genauso verhält es sich bei den gefüllten Kreisen, deren Befehl lautet matrix.fillCircle(x,y, r, LED_COLOR);. Aus der Breite der Matrix resuliert der maximal darstellbare Radius von 3, alles größere ist außerhalb der Matrix. (Mittelpunkt 1 + Radius 3 x 2 =7)

Beispiel: Ein Kreis mit einem Radius von 3, ausgehend von (3;3) in rot, darin ein ausgefüllter, gelber Kreis mit einem Radius von 2, auch ausgehend von (3;3) und darin wieder ein grüner, ausgefüllter Kreis, ebenfalls ausgehend von (3;3) mit einem Radius von 1.

matrix.drawCircle(3,3, 3, LED_RED);
matrix.fillCircle(3,3, 2, LED_YELLOW);
matrix.fillCircle(3,3, 1, LED_GREEN);
Bitmaps

Bitmaps stellen eine Möglichkeit dar, andere Formen darzustellen als Linien, Rechtecke oder Kreise. Man konfiguriert im Setup die Karte der Matrix so, dass man sie nacher beliebig oft und in allen drei Farben darstellen kann.

Um die Bitmaps zu initialisieren, fügt man unter die geschweifte Klammer des Setups die Zeile static const uint8_t PROGMEM ein. Darunter dann der Name der Bitmap in folgender Form: bitmap_name[] =. Die Nächste Zeile öffnet man dann mit einer geschweiften Klammer, und einem Leerzeichen ein B mit "01010101" dahinter am Ende ein Komma. Die 0 steht für einen ausgeschalteten Pixel und die 1 für einen eingeschalteten Pixel { B01010101, in der nächsten Zeile dann ohne geschweifte Klammer B10101010, usw. bis zur 8. Zeile, die mit einer geschweiften Klammer und einem Semikolon endet B01010101 };. Möchte man nun anstatt der einen Bitmap zwei oder mehrere konfigurieren, beendet man die 8. Zeile mit einem Koma statt des Semikolons und benennt die nächste Bitmap usw. 

 B01010101 },
bitmap_name2[] =
{ B10101010,

ACHTUNG! Nach der letzten geschweiften Klammer aller Bitmaps muss immer ein Semikolon folgen!

Beispiel:

static const uint8_t PROGMEM
  bitmap1[] =
  { B01010101,
    B10101010,
    B01010101,
    B10101010,
    B01010101,
    B10101010,
    B01010101,
    B10101010 },
  bitmap2[] =
  { B10101010,
    B01010101,
    B10101010,
    B01010101,
    B10101010,
    B01010101,
    B10101010,
    B01010101 };

Um die Bitmap anzuzeigen, betötigt man den Befehl: matrix.drawBitmap(x,y, bitmap_name, l,b, LED_COLOR);. X und Y geben die Ausgangspunkte der Bitmap an, im Normalfall ist das (0;0), falls man die Bitmap verschieben möchte, kann man die Koordinate variieren. L und B geben die Maße der Matrix an, in diesem Falle 8,8,. COLOR ist wieder eine der Farben YELLOW, RED oder GREEN.

Tipp:Es empfiehlt sich vor jedem Abbild einer Bitmap die Matrix zu "clearen".

Beispiel:
matrix.drawBitmap(0,0, bitmap1, 8,8, LED_RED);
matrix.drawBitmap(0,0, bitmat2, 8,8, LED_GREEN);
Drehen des Displays

Mit dem Befehl matrix.setRotation(x); kann man die Ausrichtung der Matrix bestimmen. Dabei entspricht 0 der Ausgangsposition, 1 einer 90° Drehung, 2 einer 180° Drehung, 3 einer 270° Drehung, während 4 wieder der Ausgangsposition entspricht. Diese Abfolge lässt sich beliebig lange fortsetzen, so dass sich unter Einsatz eines Counters das Display stetig weiterdreht.

Abschließend zur Lichtorgel

Alle gezeigten Beispiele lassen sich beliebig kombinieren, der Kreativität sind keine Grenzen gesetzt. Unter Berücksichtung aller Beispiele habe ich ein Lichtabfolge geschrieben, in der man sich die einzelnen Elmente beispielhaft im Code ansehen kann: Download

Textdarstellung

Es ist möglich auch ohne das vorherige Definieren von Bitmaps für jedes einzelne Zeichen. Mit dem Befehl matrix.print("Text"); lässt sich ganz einfach Text darstellen. Jedoch reicht dieser Befehl alleine nicht aus. Zuvor muss mit matrix.setTextColor(LED_COLOR) die Farbe festgelegt werden. ACHTUNG Mit dem Befehl können lediglich einzelne Zeichen dargestellt werden.

Text bewegen

Um Zeichenfolgen darzustellen, müssen sich die Zeichen bewegen. Zuerst muss man definieren von wo nach wo sich der Text bewegen soll. Es bietet sich an, ihn in x-Richtung zu bewegen, um eine Art Newsticker zu imitieren. Mit for (int8_t x=x1; x>=x2; x--){ setzt man die Start- und Endpunkte, in dem man die x-Koordinate variert. die Um den Text vom rechten Rand einzubleben, muss x1 größer 7 sein, soll der Text ganz nach links aus dem Display bewegen, muss x1 größer sein als alle Breiten der einzelnen Zeichen addirt. Beispiel "Test": pro Buchstabe 5 Pixel und pro Leerzeichen 1 Pixel ergibt in der Summe 23. Man muss also mindestens -23 für x2 eitragen damit der Text nach links die Matrix verlässt.

Nach die Start-x-Koordnate definiert ist braucht man nun einen Cursor, der definiert von wo ausgehend der Text dargestellt werden soll. Mit matrix.setCursor(x,y); lässt man den Text ab dem Punkt(x,y) in x und y Richtung erscheinen. Gibt man für y=0 an und lässt x als Variable, so wird sie mit jededem Durchgang des Loops um einen kleiner (durch x--) wodurch der Cursor und somit letzendlich auch der Text verschoben wird. Kehrt man alls um, so kann man den Text auch von links nach rechts laufen lassen (for (int8_t x=x1; x<=x2; x++){

ACHTUNG! Damit der Text sich bewegt und dabei lesbar ist, muss nach jedem Durchlauf eine Pause einbaut werden. Es empfehlen sich 75-125ms). Des weiteren muss die Matrix nach jedem Durchlauf gesäubert werden, da sonst alles kumultativ dargestellt werden. Ebenfalls essentiell ist matrix.setTextWrap(false);, damit keine Zeilenumbrüche erstellen und so jeder Buchstabe einzeln und nicht aneinandergereiht erscheint.
Hier sieht man was passiert wenn man keine Verzögerung (delay(t in ms);) einbaut Mit Verzögerung bewegt sich der Text einwandfrei

Beispiel: 

matrix.setTextWrap(false);
matrix.setTextColor(LED_GREEN);
for (int8_t x=7; x>=-23; x--){ 
    matrix.clear();
    matrix.setCursor(x,0);
    matrix.print("Test");
    matrix.writeDisplay();
    delay(75);
  }

Man kann mit dem Befehl matrix.setTextSize(x); die Größe des Texts anpassen, wobei x die Breite der Schrift in Pixeln angibt. Alles größer als 1 lässt sich nicht auf einem 8x8 Display nicht darstellen. Weshalb der Befehl bei dieser Matrix unnütz ist.

Abschließend zur Textdarstellung

Ein Beispiel für die Textdarstellung habe ich hier zusammengestellt, worin man sich die einzelnen Befehle noch mal im Sketch ansehen kann.

Snake-Game

Um das Spiel Snake auf der Matrix zu spielen, benötigt man eine Eingabequelle. Hier bietet sich ein Keypad an, welches auch käuflich erworben werden kann.[1].

Keypad

Damit alle Funktionen des Keypads genutzt werden können, muss die Keypad Library geladen und <a href =#LIBR>installiert </a> werden. Um das Keypad korrekt einzusetzen musst es erst definiert werden. Dies funktioniert wie folgt: 

#include "Keypad.h"
const byte ROWS = 4; //das Keypad hat vier Reihen
const byte COLS = 4; //das Keypad hat vier Spalten
//definieren der Keymap, bzw. welcher Key auf welchem Feld liegt
char keys[ROWS][COLS] = { 
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {5, 4, 3, 2}; //definieren an Welchen Pins die Reihen liegen
byte colPins[COLS] = {9, 8, 7, 6}; //definieren an Welchen Pins die Spalten liegen

Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );

Mit dem Befehl keypad.getKey(); kann man den aktuellen Key auslesen, wenn kein Key gedrückt wird ist Key = NO_KEY. Ein kleines Beispiel für die Kombination aus Matrix und Keypad gibt es hier.

Grundstruktur

Der Spielcode besteht aus vier Bereichen: Der Initialisierung, dem Setup, dem Loop und den einzelnen Funktionen des Loops. In der Initialisierung werden die Libraries abgerufen, das Keypad initialisiert und die Variablen definiert. Im Setup wird der serielle Monitor gestartet, die Matrix angesteuert und zufällig die Startposition für die Schlange und die erste Frucht festgelegt. Im Loop laufen die Funktionen, die die Schlange bewegen, sie verlängern lassen und neue Früchte zeichnen. Außerdem wird überprüft ob die Schlange sich selber trifft um das Spiel gegebenenfalls zu beenden.

Funktionen des Loops

Man braucht eine Funktion, um zu prüfen ob ein Knopf gedrückt um evtl. die Richtung zu ändern. Zuerst ruft man mit keypad.getKey(); den aktuellen Key abzurufen. Wenn der nun gleich dem Key ist, der die Richtung ändern soll, tut dieser das.

Des weiteren braucht man eine Funktion, die entweder die Schlange und die Frucht auf dem Spielfeld postiert oder anzeigt, das das Spiel vorbei ist. Dies geht mit if (!gameover) und else. Dann zeigt man bei else mittels Textadarstellung "Game over".

Es wird ebenfalls Funktion benötigt, die die Koordinaten der Schlange definiert, in dem sie prüft, welche Richtung durch die Knöpfe, bzw. die Initialisierung festgelegt wurde. Sie vergrößert auch die Länge nach dem Treffen einer Frucht und prüft ob die neue Kopfkoordinate in der Schlange selbst liegt um das Spiel zu beenden.Damit die Schlange sich mit konstanter Geschwindigkeit fortbewegt, läuft ein timer, der stetig die Delay time checkt um im loop zu blinken.

Um die Frucht zu zeichnen, bedarf es einer Funktion, die die Koordinaten für die Furcht festlegt. Sie wählt eine zufällige Position und prüft, ob diese bereits auf der Schlange liegt, um dies zu verhindern. Damit die Frucht blinkt, läuft ein timer, der stetig die Delay time checkt um im loop zu blinken.

Um zu prüfen, ob die Koordinaten an entsprechender Stelle liegen, sind mehrere boolean Variablen nötig, die dann die jeweiligen Koordinaten unter den entsprechenden Bedingungen als war oder falsch definieren.

Das Gehäuse

Damit das Snake Game gut zur Geltung kommt, kann man ein Gehäuse für Matrix, Arduino und Keypad bauen. Dazu benötigt man:

Als erstes zeichnet man die Bauteile auf die Holzplatte auf:

Seitenwand Keypad Matrix
side keypadrest matrixrest

Nach dem aufzeichnen auf die Platte, sägt man alle Teile aus und klebt sie entweder mit Leim oder mit Heißklebe zusammen. Anschließend lackiert man den Automaten. Man kann auch alles vorest auf Pappe aufzeichnen, um einen Prototypen anzufertigen.

prototyp lackierung

Nun kann man die Matrix von hinten einsetzen und das Keypad aufkleben. Enweder mit der Unterseite, die selbstklebend ist, oder mit Klebeband.

keypad

Jetzt noch den Arduino auf ein Brettchen schrauben, dass unten eingeklemmt werden kann und ein Loch für den USB-Port sägen. Fertig ist der Daddelautomat.

brettchen USBPort final

Abschließend zum Snake Game

Der Code zum Snake Game kann hier aberufen werden. ACHTUNG! Ohne die entsprechenden Libraries funtioniert das Spiel nicht ordnungsgemäß. Viel Spaß beim daddeln.

Anhang

Installieren von Libraries

Wenn man sich eine Library geladen hat, muss man die .zip Datei entpacken. Dies geht ganz einfach durch doppelklicken. Dann muss man evtl den Order umbennen. Lädt man bspw. eine Library von GitHub, muss man das -master aus dem Namen des Ordners entfernen. Anschließend muss der Ordner an den richtigen Ort. Das Folgende bezieht sich aussschließlich auf Mac.

Als erstes führt man auf dem Icon des Arduino IDE Programms einen Rechtsklick aus und wählt "Packetinhalt zeigen" an. Dann bewegt man sich zum Ordner libraries Contents->Java->libraries. Dort hinein kopiert man nun den Ordner der Library die man installieren möchte. Damit ist die Library installiert und kann jetzt verwendet werden.

Quellen

Zusammenbau

https://www.arduino.cc/en/Main/arduinoBoardUno

https://learn.adafruit.com/adafruit-led-backpack/bi-color-8x8-matrix

https://github.com/adafruit/Adafruit_LED_Backpack

https://github.com/adafruit/Adafruit-GFX-Library

Lichtorgel

https://github.com/adafruit/Adafruit_LED_Backpack/blob/master/examples/bicolor8x8/bicolor8x8.pde

Textdarstellung

https://github.com/adafruit/Adafruit_LED_Backpack/blob/master/examples/bicolor8x8/bicolor8x8.pde

Snake Game

https://github.com/Chris--A/Keypad

http://www.instructables.com/id/Access-control-with-Arduino-Keypad-4x4-Servo/step5/UPDATE-And-now-the-programming/

https://www.arduino.cc/en/Reference/Boolean

https://www.arduino.cc/en/Reference/RandomSeed

https://www.arduino.cc/en/Reference/Else

Snake Quellcode auf Basis eines Projekts von Bjoern Fischer

http://bjoernfi.de/category/arduino-als-spielekonsole/ ff.

Links zu den Code-Datein

Test-Code

Standard-Schema Matrix

Lichtorgel

Text-Display

Keypad-Beispiel

Standard Schema Keypad und Matrix

Snake Game

[1]

Dies sind weder Kaufempfehlungen, noch übernehme ich irdengwelche Verantwortung wenn diese Produkte gekauft werden. Ich bekomme auch kein Geld von den Betreibern um die Links hier zu veröffentlichen, sie sollen lediglich eine etwaige Suche erleichtern.