8×8 LED-Matrix mit MAX7219 meistern: Lauftext & Android-Bluetooth-Steuerung

In diesem Arduino-Tutorial lernen Sie, wie Sie eine 8×8-LED-Matrix mit dem MAX7219-Treiber und dem Arduino-Board steuern. Sie können das folgende Video ansehen oder die schriftliche Anleitung unten lesen.

Überblick

Wir realisieren drei Beispiele: Erstens erklären wir das Grundprinzip des MAX7219, zweitens zeigen wir, wie Lauftext auf der 8×8-Matrix funktioniert, und drittens steuern wir die Matrix per Bluetooth mit einer selbst erstellten Android-App.

MAX7219

Der MAX7219-Treiber kann 64 einzelne LEDs ansteuern, während er nur 3 Drähte für die Kommunikation mit dem Arduino benötigt. Noch besser: Mehrere Treiber und Matrizen können in Reihe geschaltet (Daisy-Chaining) werden – und man verwendet immer noch dieselben 3 Drähte.

Die 64 LEDs werden von 16 Ausgangspins des ICs getrieben. Wie ist das möglich? Tatsächlich leuchten maximal 8 LEDs gleichzeitig. Die LEDs sind als 8×8-Matrix aus Zeilen und Spalten angeordnet. Der MAX7219 aktiviert jede Spalte für einen sehr kurzen Zeitraum und treibt gleichzeitig jede Zeile an. Durch das schnelle Durchschalten von Spalten und Zeilen nimmt das menschliche Auge ein kontinuierliches Licht wahr.

Beachten Sie die interne Pin-Belegung einer gängigen 8×8-LED-Matrix – falls Sie eine Matrix selbst aufbauen, sollten Sie dies berücksichtigen.

Ein gängiges Breakout-Board für den MAX7219 hat einen Widerstand zwischen 5 V und Pin 18 des ICs. Dieser Widerstand legt die Helligkeit bzw. den Stromfluss zu den LEDs fest. Die folgende Tabelle aus dem Datenblatt zeigt den Widerstandswert je nach Vorwärtsspannung der LEDs.

Schaltplan

Verbinden wir die 8×8-LED-Matrix mit dem Arduino. Hier der Schaltplan:

VCC und GND des Moduls gehen an 5 V bzw. GND des Arduino. Die drei Pins DIN, CLK und CS können an beliebige digitale Pins angeschlossen werden. Für mehrere Module verbindet man einfach die Ausgangspins des vorherigen Boards mit den Eingängen des nächsten (DOUT des vorherigen an DIN des nächsten).

Benötigte Komponenten:

8×8 LED MAX7219 Dot Matrix Modul
HC-05 Bluetooth-Modul
Arduino Board
Steckbrett und Jumper-Kabel

Grundlegender MAX7219 Arduino-Code

Nach dem Anschließen sehen wir uns den Code für das erste Beispiel an. Wir nutzen die MaxMatrix-Bibliothek (GitHub: riyas-org/max7219).

/* 8x8 LED Matrix MAX7219 Example 01 by Dejan Nedelkovski, www.HowToMechatronics.com
   Based on: GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */
#include <MaxMatrix.h>
int DIN = 7;
int CLK = 6;
int CS = 5;
int maxInUse = 1;
MaxMatrix m(DIN, CS, CLK, maxInUse);
char A[] = {4, 8, B01111110, B00010001, B00010001, B01111110, };
char B[] = {4, 8, B01111111, B01001001, B01001001, B00110110, };
char smile01[] = {8, 8, B00111100, B01000010, B10010101, B10100001, B10100001, B10010101, B01000010, B00111100 };
char smile02[] = {8, 8, B00111100, B01000010, B10010101, B10010001, B10010001, B10010101, B01000010, B00111100 };
char smile03[] = {8, 8, B00111100, B01000010, B10100101, B10010001, B10010001, B10100101, B01000010, B00111100 };
void setup() {
  m.init();
  m.setIntensity(8); // Helligkeit 0-15
}
void loop() {
  m.setDot(6,2,true); delay(1000);
  m.setDot(6,3,true); delay(1000);
  m.clear();
  for (int i=0; i<8; i++){ m.setDot(i,i,true); delay(300); }
  m.clear();
  m.writeSprite(2, 0, A); delay(1000);
  m.writeSprite(2, 0, B); delay(1000);
  m.writeSprite(0, 0, smile01); delay(1000);
  m.writeSprite(0, 0, smile02); delay(1000);
  m.writeSprite(0, 0, smile03); delay(1000);
  for (int i=0; i<8; i++){ m.shiftLeft(false,false); delay(300); }
  m.clear();
}Code language: Arduino (arduino)

Erläuterung: Zuerst binden wir MaxMatrix.h ein, definieren Pins, Anzahl der Module und das MaxMatrix-Objekt.

Für die Zeichenanzeige definieren wir Zeichen als Byte-Arrays. Die Bits bilden die Zeichen (Nullen und Einsen). Sie sind um 90° gedreht, was die spätere Implementierung der shiftLeft-Funktion für Lauftext erleichtert.

Im setup() initialisieren wir das Modul und setzen die LED-Helligkeit. Im loop() können wir mit setDot() einzelne LEDs an Position X/Y setzen und mit clear() das Display löschen.

Vordefinierte Zeichen zeigen wir mit writeSprite() an (erste zwei Argumente: X/Y der linken oberen Ecke). Am Ende scrollen wir das Zeichen mit shiftLeft() nach links.

8×8 LED Matrix Lauftext Arduino-Code

Nun zum Lauftext-Beispiel – was ist anders? Unter dem Code finden Sie die Erklärung.

/* 8x8 LED Matrix MAX7219 Scrolling Text Example
   Based on: GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */
#include <MaxMatrix.h>
#include <avr/pgmspace.h>
PROGMEM const unsigned char CH[] = {
  3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
  1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
  3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
  5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
  4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
  5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
  5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
  1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
  3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
  3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
  5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
  5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
  2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
  4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
  2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
  4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
  4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
  3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
  4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
  4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
  4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
  4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
  4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
  4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
  4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
  4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
  2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
  2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
  3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
  3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
  3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
  4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
  5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
  4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
  4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
  4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
  4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
  4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
  4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
  4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
  4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
  3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
  4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
  4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
  4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
  5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
  5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
  4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
  4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
  4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
  4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
  4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
  5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
  4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
  5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
  5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
  5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
  5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
  4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
  2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
  4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
  2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
  3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // ^
  4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
  2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
  4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
  4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
  4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
  4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
  4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
  3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
  4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
  4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
  3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
  4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
  4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
  3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
  5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
  4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
  4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
  4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
  4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
  4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
  3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // s
  4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // t
  5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // u
  5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // v
  5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // w
  4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // x
  3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // y
  3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // z
  3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
  1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
  3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
  4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};
int DIN = 7;
int CLK = 6;
int CS = 5;
int maxInUse = 2;
MaxMatrix m(DIN, CS, CLK, maxInUse);
byte buffer[10];
char text[]= "HowToMechatronics.com "; // Lauftext
void setup() {
  m.init();
  m.setIntensity(15);
}
void loop() {
  printStringWithShift(text, 100); // (Text, Scrollgeschwindigkeit)
}
void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i = 0; i < buffer[0] + 1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
  }
}Code language: Arduino (arduino)

Erläuterung: Wir binden zusätzlich avr/pgmspace.h ein für PROGMEM – ein Variablen-Modifikator, der Daten im Flash-Speicher statt im SRAM ablegt. Bei großen statischen Datensätzen (hier Zeichendefinitionen) ist Flash (32 KB) gegenüber SRAM (2 KB) vorzuziehen.

Mit einem Zeichen-Array definieren wir den Lauftext. Im loop() ruft die Funktion printStringWithShift den Text mit der Scrollgeschwindigkeit (ms) auf. Diese Funktion extrahiert die Zeichen aus dem Text-String und zeigt sie scrollend auf der LED-Matrix an.

Android-App zur Steuerung der 8×8-LED-Matrix per Bluetooth

Nach dem Verständnis des MAX7219 bauen wir ein praktisches Projekt: eine eigene Android-App zur Bluetooth-Steuerung der LED-Matrix. Ich empfehle, meine Tutorials zum HC-05 Bluetooth-Modul und zur Erstellung eigener Android-Apps mit MIT App Inventor anzusehen.

Hier der Arduino-Code mit den Änderungen zum vorherigen Beispiel:

/* 8x8 LED Matrix MAX7219 Scrolling Text Android Control via Bluetooth
   by Dejan Nedelkovski, www.HowToMechatronics.com
   Based on: GitHub | riyas-org/max7219 https://github.com/riyas-org/max7219 */
#include <MaxMatrix.h>
#include <SoftwareSerial.h>
#include <avr/pgmspace.h>
PROGMEM const unsigned char CH[] = { /* ... gleiche Zeichentabelle wie oben ... */ };
int dIn = 7;
int clk = 6;
int cs = 5;
int maxInUse = 2;
MaxMatrix m(dIn, cs, clk, maxInUse);
SoftwareSerial Bluetooth(8, 7); // Bluetooth
byte buffer[10];
char incomebyte;
int scrollSpeed = 100;
char text[100] = "HowToMechatronics.com "; // Initialtext
int brightness = 15;
int count = 0;
char indicator;
void setup() {
  m.init();
  m.setIntensity(brightness);
  Bluetooth.begin(38400); // Standard-Baudrate des Bluetooth-Moduls
}
void loop() {
  printStringWithShift(text, scrollSpeed);
  if (Bluetooth.available()) {
    indicator = Bluetooth.read(); // erstes Byte = Indikator
    // "Send"-Button in App gedrückt (Indikator '1'): Text ändern
    if (indicator == '1') {
      for (int i = 0; i < 100; i++) { text[i] = 0; m.clear(); }
      while (Bluetooth.available()) {
        incomebyte = Bluetooth.read();
        text[count] = incomebyte;
        count++;
      }
      count = 0;
    }
    // Scrollgeschwindigkeit ändern (Indikator '2')
    else if (indicator == '2') {
      String sS = Bluetooth.readString();
      scrollSpeed = 150 - sS.toInt(); // niedrigerer Wert = höhere Geschwindigkeit
    }
    // Helligkeit ändern (Indikator '3')
    else if (indicator == '3') {
      String sB = Bluetooth.readString();
      brightness = sB.toInt();
      m.setIntensity(brightness);
    }
  }
}
void printCharWithShift(char c, int shift_speed) {
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7 * c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i = 0; i < buffer[0] + 1; i++) {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}
void printStringWithShift(char* s, int shift_speed) {
  while (*s != 0) {
    printCharWithShift(*s, shift_speed);
    s++;
  }
}
void printString(char* s) {
  int col = 0;
  while (*s != 0) {
    if (*s < 32) continue;
    char c = *s - 32;
    memcpy_P(buffer, CH + 7 * c, 7);
    m.writeSprite(col, 0, buffer);
    m.setColumn(col + buffer[0], 0);
    col += buffer[0] + 1;
    s++;
  }
}Code language: Arduino (arduino)

Beschreibung: Wir binden SoftwareSerial.h für Bluetooth-Kommunikation ein und definieren nötige Variablen. Im setup() initialisieren wir Bluetooth mit 38400 Baud. Initialtext: „HowToMechatronics.com“ mit 100 ms Scrollverzögerung.

Im loop() prüft Bluetooth.available() auf eingehende Daten. Das erste Byte wird in „indicator“ gespeichert und entscheidet, ob Text, Scrollgeschwindigkeit oder Helligkeit geändert wird.

In der Android-App (MIT App Inventor) sendet der „Send“-Button zuerst das Anzeigebyte „1“ (Textänderung). Am Arduino löschen wir das Zeichen-Array und das Display, dann lesen wir im while-Loop den Rest der Daten (die in der App eingegebene Nachricht).

Bei Indikator „2“ (Scrollgeschwindigkeits-Slider) lesen wir den neuen Wert per Bluetooth.readString() und passen die Geschwindigkeit an. Gleiches für Helligkeit (Indikator „3“).

Hier können Sie die Android-App herunterladen:

Android-App für Arduino 8x8 LED Matrix Steuerung

1 file(s) 1.48 MB Download 8×8 LED-Matrix mit MAX7219 meistern: Lauftext & Android-Bluetooth-Steuerung

Android-App für Arduino 8×8 LED Matrix Steuerung .aia Datei

1 file(s) 34.06 KB Download

Das war alles für dieses Tutorial. Fragen gerne in den Kommentaren!