Eine einzelne LED kann beim Testen von Arduino-Projekten hilfreich sein. Wenn Sie jedoch eine LED-Matrix hinzufügen, können Sie wirklich kreativ werden und Buchstaben, Zahlen und Symbole buchstabieren. Es ist auch eine praktische Möglichkeit zu lernen, wie komplexere Displays – wie die, auf der Sie dies lesen – funktionieren. In diesem Handbuch zeigen wir Ihnen, wie Sie eine grundlegende 8 × 8-LED-Matrix einrichten.
Funktionsweise von LED-Matrizen
Eine grundlegende LED-Matrix wie die, die wir verwenden, verfügt über ein 8 × 8-Raster von LEDs, mit denen Zeichen, grundlegende Bilder und mehr gezeichnet werden können. In früheren Anleitungen haben wir gezeigt, wie der Arduino eine einzelne LED steuern kann. Diese Komponente erstreckt sich dieses Konzept über ein Array von 64 LEDs, die alle mit einem einzigen Arduino gesteuert werden können.
LED-Matrix
In einer LED-Matrix wird ein Strom durch Reihen von LEDs geleitet. Um den Stromkreis zu vervollständigen und ein einzelnes Licht zu aktivieren, wird eine Säule mit Masse verbunden. Wo sich die Strom- und Masseleitungen schneiden, werden LEDs aktiviert. Sie können es sich ein bisschen wie das Brettspiel Battleship vorstellen. Wenn beispielsweise die Zeilen A, B und C mit Strom versorgt werden, aber nur Spalte 1 mit Masse verbunden ist, leuchten die Lichter an A1, B1 und C1 auf. Der Rest bleibt dunkel.
Dies ist eine praktische Möglichkeit, mehrere LEDs gleichzeitig einzuschalten, verursacht jedoch ein Problem, wenn nur bestimmte LEDs in einer Spalte eingeschaltet werden sollen. Angenommen, Sie wollten stattdessen, dass die Lichter A1, B2 und C3 aufleuchten und eine diagonale Linie bilden. Das Aktivieren aller drei Zeilen und Spalten würde das gesamte Raster aktivieren, was nicht das ist, was wir wollen.
Um dieses Problem zu lösen, kann ein Arduino eine Schleife durchlaufen und jeweils nur eine einzelne LED-Reihe aktivieren. Auf diese Weise können Sie beliebig viele Spalten aktivieren, ohne die nächste Zeile zu beeinflussen. Ohne eine lange Delay () -Funktion werden die Zeilen so schnell hintereinander aktiviert, dass das menschliche Auge sie nicht erkennen kann. Wir werden jedoch zeigen, wie Sie eine Verzögerung hinzufügen, damit Sie sehen können, wie es trotzdem funktioniert.
Was Sie brauchen
Wir verwenden eine kompliziertere Methode, um die LED–Matrix für Bildungszwecke zu steuern – andere Komponenten können die Anzahl der benötigten Pins reduzieren – und so wird dies einige mehr Pins und Drähte erfordern als die meisten unserer anderen Guides. Aus diesem Grund verwenden wir anstelle des üblichen Arduino Uno einen Arduino Mega 2560, um diese Matrix zu steuern. Sie benötigen außerdem Folgendes:
| Arduino Mega 2560 |  |
| 8×8 GEFÜHRTE Matrix |  |
| 8 x 220ohm Widerstand
Die meisten LEDs brennen aus, wenn Sie sie direkt an den 5V-Ausgang eines Arduino anschließen. Platzieren Sie einen Widerstand aus Ihrem Kit zwischen dem Ausgangspin und der LED. |
 |
| EIN paar breadboards |  |
| Arduino IDE |  |
Sie benötigen außerdem ein USB-Kabel und einige Kabel – mindestens 32!
Es gibt eine Reihe von Möglichkeiten, die Verkabelung für dieses Projekt zu organisieren, aber da es komplex werden kann, empfehlen wir, ein Paar Steckbretter zu verwenden, eines für die LED-Matrix und ein anderes für die Verkabelung in den Widerständen. Es ist möglich, dasselbe zu erreichen, indem Drähte mit weiblichen Enden verwendet werden, die zur LED-Matrix verlaufen, obwohl sie zur Seite sitzen, anstatt stationär, was etwas umständlicher sein kann.
Der Code
Der Code für dieses Projekt verwendet Schleifen und Arrays, um jede LED einzeln zu schreiben. Das Ergebnis ist ein Array oben in Ihrem Skript, das Sie leicht ändern können, um das Bild zu ändern, das Ihre LED-Matrix anzeigt. Fügen Sie zuerst den vollständigen Code in die Arduino IDE ein und laden Sie ihn auf Ihren Arduino Mega hoch.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
int toDisplay = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};
void setup() {
für (int i=2; i<=9; i++) {
pinMode(i, AUSGABE);
pinMode (ich + 44, AUSGANG);
digitalWrite (ich, NIEDRIGEN);
digitalWrite (ich + 44, HOHE);
}
pinMode (A0, EINGANG);
}
void loop() {
für (int i=0; i<8; i++) {
wenn (i==0) {
digitalWrite(9, NIEDRIG);
}
sonst {
digitalWrite(i+1, NIEDRIG);
}
für (int j=0; j<8; j++) {
wenn (toDisplay == 1) {
digitalWrite (j+46, NIEDRIG);
}
sonst {
digitalWrite(j+46, HOCH);
}
}
digitalWrite (i + 2, HOCH);
Verzögerung(1);
}
}
|
Als nächstes gehen wir durch, wie jeder dieser Abschnitte funktioniert.
|
1
2
3
4
5
6
7
8
9
10
|
int toDisplay = {
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,0,0},
{1,0,0,0,0,0,1,0},
{1,0,0,0,0,0,0,0},
{1,1,1,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0},
{1,0,0,1,0,0,1,0}
};
|
Vor einer der Hauptschleifen in der Skizze definiert dieses mehrdimensionale Array, welche LEDs leuchten und welche dunkel bleiben sollen. Es gibt acht Reihen mit jeweils acht Werten, die den acht Reihen von LEDs auf der Matrix entsprechen. Indem Sie sie in der Skizze in einem Raster auslegen, können Sie leichter visualisieren, welche Form die LEDs haben werden.
|
1
2
3
4
5
6
7
8
9
|
void setup() {
für (int i=2; i<=9; i++) {
pinMode(i, AUSGANG);
pinMode(i+44, AUSGANG);
digitalWrite(i, NIEDRIG);
digitalWrite(i+44 , HOCH);
}
pinMode (A0, EINGANG);
}
|
Im Abschnitt setup () initialisieren wir die Pins, die wir für die Matrix benötigen. Da es sechzehn verschiedene Pins gibt, können wir dies effizienter als einen nach dem anderen tun. Die zur Masse verlaufenden Stifte werden in die Stifte 2 bis 9 gesteckt. Die Pins, die Strom an die Matrix senden, laufen zu den Pins 46 bis 53. Dieser Abschnitt verwendet eine Schleife, um beide Pinsätze zu initialisieren.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
void loop() {
für (int i=0; i<8; i++) {
wenn (i==0) {
digitalWrite(9, NIEDRIG);
}
sonst {
digitalWrite(i+1, NIEDRIG);
}
für (int j=0; j<8; j++) {
wenn (toDisplay == 1) {
digitalWrite (j+46, NIEDRIG);
}
sonst {
digitalWrite(j+46, HOCH);
}
}
digitalWrite (i + 2, HOCH);
Verzögerung(1);
}
}
|
Im Abschnitt main loop () der Skizze gibt es eine mehrstufige Schleife. Die erste if-Anweisung setzt die zuletzt verwendete Zeile auf NIEDRIG zurück, wodurch der Stromfluss gestoppt wird.
Die nächste verschachtelte for-Schleife überprüft die Daten im Array. Wenn eine Zelle als 1 aufgeführt ist, wird das Erdungskabel für diese Spalte auf NIEDRIG gesetzt, sodass Strom abfließen kann. Andernfalls wird der Pin auf HIGH gesetzt, wodurch verhindert wird, dass eine Schaltung entlang dieser Spalte abgeschlossen wird. Dies geschieht für alle acht Zellen in einer bestimmten Zeile.
Schließlich schaltet die letzte digitalWrite() -Anweisung die gesamte Zeile ein. Alle auf NIEDRIG eingestellten Spalten leuchten auf. Der Rest bleibt dunkel. Wenn die Skizze erneut eine Schleife erstellt, wird diese Zeile sofort deaktiviert.
Der letzte Befehl ist eine delay() -Anweisung, die die Verzögerung zwischen jeder Zeile festlegt. In unserem Beispiel ist es auf 1 Millisekunde eingestellt, da die LEDs etwas zu schwach werden, wenn die Anweisung nicht vorhanden ist. Sie können jedoch die Verzögerung erhöhen, um zu sehen, was die Skizze langsamer macht. Sie sollten sehen, dass jede Reihe einzeln aufleuchtet, bevor Sie sie ausschalten, wenn sich die nächste Reihe einschaltet.
Die Verdrahtung
Für dieses projekt, die verdrahtung ist relativ einfach, es gibt nur eine menge von es. Da es viele Pins gibt, beschreiben wir, was Sie für jede komplette Schaltung tun möchten, anstatt jeden einzelnen Draht aufzulisten, wie wir es normalerweise tun.
Die Pins 2 bis 9 sollten Ihre Stromversorgungspins und die Pins 46 bis 53 Ihre Massepins sein. Führen Sie ein Kabel vom Power–Pin zur LED-Matrix (weitere Informationen zu den Pins finden Sie unten – dies ist wichtig), von der LED-Matrix zu einem 220-Ohm-Widerstand und führen Sie dann ein Kabel zurück zu einem Pin am Arduino. Pin 2 sollte schließlich zu Pin 46 führen, Pin 3 sollte zu Pin 47 führen und so weiter.
Die Hauptkomplikation liegt hier in der LED-Matrix selbst. Kontraintuitiv sind die Pins auf beiden Seiten der Matrix überhaupt nicht in einer kohärenten Reihenfolge. Zum Beispiel möchten wir, dass Pin 2 das versorgt, was wir Zeile A nennen. Der Pin dafür ist jedoch der vierte Pin von links oben auf der LED-Matrix. Das andere Ende dieser Schaltung – die zu Spalte 1 führen soll – ist der erste Pin rechts unten in der Matrix.
Da diese Reihenfolge ziemlich kompliziert ist, beschreiben wir, mit welchen Pins auf der Matrix jeder Arduino-Pin direkt verdrahtet werden soll.
Entlang der Oberseite der Matrix (der Seite mit der darauf gedruckten Nummer) befinden sich acht Stifte. Von links nach rechts sollten diese mit den folgenden Pins am Arduino verdrahtet werden:
- Stift 7
- Stift 4
- Stift 49
- Stift 2
- Stift 51
- Stift 52
- Stift 3
- Stift 5
Als nächstes sollte die untere Reihe von acht Pins auf der Matrix (die Seite ohne Zahlen) mit den folgenden Pins verdrahtet werden (von links nach rechts, wobei die Zahlen immer noch nach oben zeigen):
- Stift 9
- Stift 50
- Stift 48
- Stift 6
- Stift 53
- Stift 8
- Stift 47
- Stift 46
Sobald alle Kabel angeschlossen sind, können Sie Ihr Projekt einschalten und Ihre LED-Matrix leuchtet auf. Versuchen Sie, die Anordnung von 1s im ursprünglichen Array zu ändern, und laden Sie das Skript erneut hoch, um verschiedene Formen zu erstellen. Sie können auch die Länge des Befehls delay() anpassen, damit jede Zeile einzeln aufleuchtet.