7. Arduino - 8x8 LED Matrix

7. Arduino - 8x8 LED Matrix

Das Projekt "Arduino - 8x8 LED Matrix", bei dem im ersten Schritt ein Arduino direkt mit einer 8x8 LED-Matrix verbunden wird, bietet eine faszinierende Gelegenheit, die Grundlagen der Elektronik und Programmierung zu vertiefen. Hierbei wird die LED-Matrix an den Mikrocontroller Arduino Uno angeschlossen, entweder ohne die Nutzung zusätzlicher Hilfschip's (1. Kapitel) oder mit Schieberegister (2. Kapitel). In diesem Artikel werden wir die benötigten Komponenten, den Schaltungsaufbau, die Programmierung und die Anwendungen detailliert beleuchten.


1. Arduino - 8x8 LED Matrix - direkter Anschluss1.1. Komponenten
1.2. Aufbau der Hardware1.2.1. Verbindung der LED-Matrix
1.2.2. Anschluss an den Arduino
1.3. Programmierung1.3.1. Erklärung des Arduino Codes
2. Anzeige auf 4 LED-Matrizen mit Arduino2.1. Komponenten
2.2. Aufbau der Hardware2.2.1. Verbindung der LED-Matrizen in der Theorie:
2.2.2. Verdrahtung der Schieberegister in der Praxis:
2.3. Programmierung2.3.1. Bibliotheken installieren
2.3.2. Grundstruktur des Codes
2.3.3 Charaktere und Muster definieren
3. Laufschrift-Anzeige auf 4 LED Matrizen mit Arduino
4. Anwendungen


1. Arduino - 8x8 LED Matrix - direkter Anschluss
1.1. Komponenten

Für dieses Projekt werden folgende Komponenten benötigt:


- Arduino Uno oder ein ähnliches Board
- 8x8 LED-Matrix
- 16 x 220 Ohm Widerstände
- Breadboard
- Verbindungskabel (Jumperkabel)
1.2. Aufbau der Hardware

Der direkte Anschluss einer 8x8 LED-Matrix an den Arduino bedeutet, dass jede LED einzeln adressiert wird, ohne den Einsatz von Schieberegistern oder Treiber-ICs. Dies erfordert allerdings eine sorgfältige Planung der Pins und eine durchdachte Verkabelung.


1.2.1. Verbindung der LED-Matrix

Die 8x8 LED-Matrix besteht aus 64 LEDs, die in einem Raster angeordnet sind. Jede LED ist durch eine Zeilen- und Spaltenadresse zugänglich. Die Kathoden (Minus-Pol) der LEDs sind mit den Spalten und die Anoden (Plus-Pol) mit den Zeilen verbunden.


1.2.2. Anschluss an den Arduino

Verbinde die Anoden (oder Kathoden, je nach Typ der LED-Matrix) der LEDs mit den digitalen Pins des Arduino. In der unten dargestellten Matrix sind es die Spalten (Pin 13, 3,...).




Verwende 220 Ohm Widerstände, um die LEDs vor zu hohen Strömen zu schützen. Diese Widerstände können zwischen den digitalen Pins und der LED-Matrix oder zwischen den gemeinsamen Anschlüssen (Anoden oder Kathoden) und GND/5V eingefügt werden.


Hier siehst du nun wie es aufgebaut sein sollte:



1.3. Programmierung

Die Programmierung einer 8x8 LED-Matrix erfordert die Steuerung jeder einzelnen LED durch die digitale Ansteuerung der entsprechenden Pins. Hier ein Beispielcode, der ein einfaches Lauflichtmuster darstellt:


#define ROW_1 2
#define ROW_2 3
#define ROW_3 4
#define ROW_4 5
#define ROW_5 6
#define ROW_6 7
#define ROW_7 8
#define ROW_8 9
#define COL_1 10
#define COL_2 11
#define COL_3 12
#define COL_4 13
#define COL_5 A0
#define COL_6 A1
#define COL_7 A2
#define COL_8 A3
const byte rows = {
ROW_1, ROW_2, ROW_3, ROW_4, ROW_5, ROW_6, ROW_7, ROW_8
};
byte letter0 = {
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000,
B00000000};
byte letter1 = {
B10000001,
B10000001,
B10000001,
B10000001,
B11111111,
B10000001,
B10000001,
B10000001};
byte letter2 = {
B00011000,
B00100100,
B01000010,
B11111111,
B10000001,
B10000001,
B10000001,
B10000001};
byte letter3 = {
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B10000000,
B11111111};
byte letter4 = {
B00011000,
B00100100,
B01000010,
B10000001,
B10000001,
B01000010,
B00100100,
B00011000};
float timeCount = 0;
void setup() {
for (byte i = 2; i > 0) & 0x01);
digitalWrite(COL_2, (~b >> 1) & 0x01);
digitalWrite(COL_3, (~b >> 2) & 0x01);
digitalWrite(COL_4, (~b >> 3) & 0x01);
digitalWrite(COL_5, (~b >> 4) & 0x01);
digitalWrite(COL_6, (~b >> 5) & 0x01);
digitalWrite(COL_7, (~b >> 6) & 0x01);
digitalWrite(COL_8, (~b >> 7) & 0x01);
}
1.3.1. Erklärung des Arduino Codes
- Pin-Definitionen: Die Pins für die Zeilen und Spalten der LED-Matrix werden in COL und ROW definiert. Zusätzlich werden noch Arrays definiert (byte letter0 bis byte letter4), die die Symbole für die spätere Darstellung enthalten.
- Setup-Funktion: Die Pins der Zeilen und Spalten werden als Ausgänge konfiguriert.
- Loop-Funktion: Die "loop"-Funktion durchläuft die verschiedenen Arrays Schritt für Schritt und stellt diese auf der Matrix dar.


2. Anzeige auf 4 LED-Matrizen mit Arduino
2.1. Komponenten
- Arduino Uno oder vergleichbares Board
- 4 x 8x8 LED-Matrizen
- 4 x MAX7219 Platinen
- Jumper-Kabel
2.2. Aufbau der Hardware
2.2.1. Verbindung der LED-Matrizen in der Theorie:
- Jede LED-Matrix besteht aus 64 LEDs, die in einem 8x8-Raster angeordnet sind.
- Die MAX7219 Schieberegister werden verwendet, um die LEDs der Matrizen zu steuern, und erleichtern die Multiplexing-Aufgaben erheblich.
2.2.2. Verdrahtung der Schieberegister in der Praxis:
- Verbinde die Daten-, Takt- und Speicher-Latch-Pins der Schieberegister mit den digitalen Pins des Arduino (siehe Aufbaubild)
- Die 4 LED-Matrizen werden in Reihe geschaltet. Die `DOUT`-Pins der ersten zweiten und dritten Matrizen werden mit den `DIN`-Pins der nächsten Matrizen verbunden.
- Verbinde die Ausgänge der Schieberegister mit den Zeilen- und Spaltenanschlüssen der LED-Matrix.


2.3. Programmierung
2.3.1. Bibliotheken installieren

Für die Arbeit mit MAX7219 verwenden wir die "LedControl" Bibliothek. Diese erleichtert die Steuerung der LED-Matrix.


- Öffne die Arduino-IDE und gehe zu Sketch -> Bibliothek einbinden -> Bibliothek verwalten.- Suche nach "LedControl" und installiere sie.


2.3.2. Grundstruktur des Codes
#include
// Pins für die LED-Matrizen
#define DATA_IN 11
#define CLK 13
#define CS 10
#define NUM_MATRICES 4
LedControl lc = LedControl(DATA_IN, CLK, CS, NUM_MATRICES);
void setup() {
for (int i = 0; i < NUM_MATRICES; i++) {
lc.shutdown(i, false);
// Wake up displays
lc.setIntensity(i, 8);
// Set brightness level (0 is min, 15 is max)
lc.clearDisplay(i);
// Clear displays
}
}
void loop() {
displayMessage(YOU);
delay(500);
}
void displayMessage(String message) {
for (int letter = 0; letter
0) {
lc.setRow(letter + (NUM_MATRICES-1) - letterRun, row, charMap);
}
}
}
delay(500);
}
}
void displayCharacter(char c) {
switch (c) {
case 'F':
charMap = 0b01111110;
charMap = 0b00000010;
charMap = 0b00011110;
charMap = 0b00000010;
charMap = 0b00000010;
charMap = 0b00000010;
charMap = 0b00000010;
charMap = 0b00000010;
break;
case 'N':
charMap = 0b10000001;
charMap = 0b10000011;
charMap = 0b10000101;
charMap = 0b10001001;
charMap = 0b10010001;
charMap = 0b10100001;
charMap = 0b11000001;
charMap = 0b10000001;
break;
case 'I':
charMap = 0b00111100;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00111100;
break;
case '-':
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b01111110;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
break;
case 'E':
charMap = 0b11111111;
charMap = 0b00000001;
charMap = 0b00000001;
charMap = 0b11111111;
charMap = 0b11111111;
charMap = 0b00000001;
charMap = 0b00000001;
charMap = 0b11111111;
break;
case 'H':
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b11111111;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
break;
case 'T':
charMap = 0b11111111;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
break;
case 'R':
charMap = 0b00111111;
charMap = 0b01000001;
charMap = 0b10000001;
charMap = 0b01000001;
charMap = 0b00111111;
charMap = 0b01000001;
charMap = 0b10000001;
charMap = 0b10000001;
break;
case 'A':
charMap = 0b00111100;
charMap = 0b01000010;
charMap = 0b10000001;
charMap = 0b11111111;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
break;
case 'M':
charMap = 0b11111111;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
break;
case 'S':
charMap = 0b11111111;
charMap = 0b00000001;
charMap = 0b00000001;
charMap = 0b11111111;
charMap = 0b10000000;
charMap = 0b10000000;
charMap = 0b10000000;
charMap = 0b11111111;
break;
case '.':
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00011000;
charMap = 0b00011000;
break;
case 'W':
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b10011001;
charMap = 0b01100110;
break;
case 'Y':
charMap = 0b10000001;
charMap = 0b01000010;
charMap = 0b00100100;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
charMap = 0b00011000;
break;
case 'O':
charMap = 0b00111100;
charMap = 0b01000010;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b01000010;
charMap = 0b00111100;
break;
case 'U':
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b10000001;
charMap = 0b01000010;
charMap = 0b00111100;
break;
default:
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
charMap = 0b00000000;
// Empty
}
}


4. Anwendungen
- Animierte Anzeigen: Mit der 8x8 LED-Matrix können einfache Animationen erstellt werden, z. B. Lauflichter, Textscrolling oder einfache Grafiken.
- Spiele: Die LED-Matrix kann als Anzeige für einfache Spiele wie Snake oder Tetris verwendet werden. Hierbei kann der Arduino sowohl die Anzeige steuern als auch die Spiellogik verarbeiten.
- Sensoranzeigen: In Kombination mit Sensoren kann die LED-Matrix zur Visualisierung von Sensordaten verwendet werden, z. B. zur Anzeige der Umgebungstemperatur oder der Helligkeit.
- Uhren und Timer: Durch Anzeigen von Uhrzeit oder Countdown-Timern kann die LED-Matrix auch im praktischen Alltag eingesetzt werden. https://smarthome-assistant.info/7-arduino-8x8-led-matrix/

Kommentare

Kommentar veröffentlichen

Beliebte Posts aus diesem Blog

10. Arduino - Spannungsmessung am Fotowiderstand

Bild
In der Welt der Elektronik gibt es viele Sensoren und einer der faszinierendsten kommt im Projekt "Arduino - Spannungsmessung am Fotowiderstand" vor. Dieses Bauteil ist besonders für DIY-Projekte und innovative Anwendungen bei DIY-Bastlern zum Teil von Bedeutung. Der Fotowiderstand, auch als lichtempfindlicher Widerstand bekannt, hat die Fähigkeit, seine Widerstandswerte basierend auf der Lichtintensität zu ändern. In diesem Artikel werden wir die Funktionsweise des Fotowiderstands , seine Anwendungen, den Aufbau eines einfachen Arduino-Projekts und vieles mehr erkunden. 1. Was ist ein Fotowiderstand? 2. Funktionsweise und Anwendungen 3. Erklärung des Spannungsteilers mit Bezug auf den Fotowiderstand 3.1. Grundlagen des Spannungsteilers 3.2. Fotowiderstand im Spannungsteiler 4. Aufbau zur Messung des Fotowiderstands 4.1. Benötigte Materialien 4.2. Schaltplan für den Aufbau 5. Programmcode 5.1. Arduino-Code zur Messung des Fotowiderstands 5.2. Erklärung der Code-Struktur 6. An...
Mehr anzeigen
Bild
Der erste Home Assistant Community Day 2025 entwickelte sich zu einem beeindruckenden globalen Erfolg. Für viele technisch versierte Nutzer und Smart-Home-Enthusiasten war es die perfekte Gelegenheit, sich lokal zu vernetzen, Automatisierungen auszutauschen und neue Kontakte innerhalb der Community zu knüpfen. Was als Frage begann, ob es überhaupt Interesse an einer global koordinierten Aktion gibt, wuchs zu einer Bewegung, die in 82 Events auf der ganzen Welt mündete. In diesem Artikel werfen wir einen detaillierten Blick auf den Verlauf des Community Days, die Herausforderungen, die daraus resultierten, und einen Ausblick auf zukünftige Events. Inhaltsverzeichnis 1. Ursprung und Idee des Home Assistant Community Day1.1 Die Bedeutung der lokalen Hosts und Teilnehmer 2. Von der Idee zur weltweiten Bewegung2.1 Regionale Vielfalt und Aktivitätsformate 2.2 Soziale Medien und digitale Begleitung 3. Herausforderungen und Learnings aus dem Event3.1 Logistische Komplexität bei Swag-Verteilung...
Mehr anzeigen
Bild
Das ESPHome-Projekt hat mit Release 2025.4.2 am 12. Mai 2025 ein weiteres Update freigegeben, das vor allem Fehlerbehebungen und Detailverbesserungen für Entwickler und Anwender bringt. Insbesondere Nutzer von ESP32 BLE und Features wie Media Player sowie Display-Treiber profitieren von gezielten Anpassungen. In diesem Artikel fassen wir alle wichtigen Änderungen zusammen und erklären, wie sie sich auf Ihre IoT-Projekte auswirken können. Inhaltsverzeichnis 1. Übersicht der Kern-Verbesserungen im Release 2025.4.21.1. Behebung unerwarteten Verhaltens bei Widget-Updates 1.2. Korrektur der BLE-Unterstützung für ESP32-C6 1.3. Fehlerbehebung bei Media Player Aktionen mit ID-Werten 2. Detaillierte Bugfixes und technische Verbesserungen2.1. Automatische Touchscreen-Auflösung für TT21100 2.2. HLW8012 Sensor – Stabilere Werteerfassung 2.3. Display-Komponente: Fix bei der Rechteck-Berechnung 2.4. Optimierung und Bereinigung bei AS3935 I2C Treiber 3. Verbesserungen an der LVGL-Integration3.1. Unte...
Mehr anzeigen