Dauerkalender

4-fach Matrix 1088AS mit Max7219 und Arduino

Aufgepasst: die 4-fach Module sehen sehr oft gleich aus, sind es aber nicht.

Neben einfachen Matrix-Modulen, die lediglich eine einzelne 8x8 Matrix enthalten, sind heute im Handel auch zusammengesetzte „Matrix-Kompositionen“, die aus mehreren Einzelelementen bestehen, erhältlich. In dem folgenden Beispiel kommt eine Zeile mit vier Einzel-Matrix-Modulen zum Einsatz. Dabei handelt es sich um LED-Matrix 1088AS mit dem Treiber Max7219, die in vierfacher Ausführung auf einer gemeinsamen Platine untergebracht sind. Eine solche Zusammenstellung eignet sich besonders gut für die Laufschrift-Effekte, die als Info- oder Werbetexte aus größerer Entfernung gut sichtbar sind.

Testschaltung für den Versuch

Um ein solches Matrix-Gespann zum Leben zu erwecken, müssen 4x8x8 = 256 LEDs gezielt zum gleichen Zeitpunkt angesteuert werden. Möchte man jede einzelne Diode separat zum Leuchten bringen, wäre das eine enorme Aufgabe für jeden Mikrocontroller - vorausgesetzt er hätte eine ausreichende Anzahl an Ausgängen. Um den Mikrocontroller zu entlasten (hier kommt Arduino ins Spiel) wird jeder Matrix ein Treiber MAX7219 vorgeschaltet. Max7219 benötigt lediglich drei Leitungen, um mit 64 LEDs fertig zu werden. Zusätzlich werden alle vier Treiber kaskadiert, d.h. in Reihe hintereinander geschaltet. Damit bleibt es bei drei Leitungen für alle 256 LEDs.

Schaltplan (Arduino ohne USB-Anschluss oder Netzteil: Vin > 6 V)

Eine Testschaltung gestaltet sich äußerst einfach. Nur drei Leitungen verbinden Arduino mit dem Matrix-Modul. Eine externe Spannungsversorgung sorgt für eine ausreichende Stromversorgung der beiden Komponenten: Arduino und Matrix-Modul.

Um eine direkte Ansteuerung der MA7219-Treiber zu umgehen, wird dem Programm eine Bibliothek, die diese Aufgabe übernimmt, hinzugefügt. Es stehen mittlerweile mehrere Bibliotheken, die sich mit MAX719 befassen, zur Verfügung. Bei bestimmten Aufgaben wird bei manchen die Programmierung zum Kopieren eines Beispielprogramms und einer passenden Parametrierung reduziert. Es ist also ratsam, bevor man loslegt, die Weiten des Internets ein wenig zu durchforsten. Hier wird die Bibliothek
LedController.hpp
(von Noa Sakurajin, https://github.com/noah1510/LedController)
angewendet. Bei Erstellung des Programms bleiben wir sportlich und verzichten nicht ganz auf die Bits-Spielereien.

#include "LedController.hpp"

#define CS 11
#define CLK 10
#define DIN 12
#define Segments 4

LedController lc = LedController(DIN,CLK,CS,Segments); 

// Zeichen und Buchstaben ---------------------------------------------------------------------------------
ByteBlock A =  { B00000000, B00011000, B00100100, B00100100, B00111100, B00100100, B00100100, B00000000 };
ByteBlock a =  { B00000000, B00000000, B00111000, B01001000, B01001000, B01001000, B00111000, B00000000 };
ByteBlock c =  { B00000000, B00000000, B00110000, B01000000, B01000000, B01000000, B00110000, B00000000 };
ByteBlock d =  { B00000000, B00001000, B00111000, B01001000, B01001000, B01001000, B00111000, B00000000 };
ByteBlock e =  { B00000000, B00000000, B00110000, B01001000, B01111000, B01000000, B00111000, B00000000 };
ByteBlock H =  { B00000000, B10010000, B10010000, B11110000, B10010000, B10010000, B10010000, B00000000 };
ByteBlock h =  { B00000000, B01000000, B01110000, B01001000, B01001000, B01001000, B01001000, B00000000 };
ByteBlock I =  { B00000000, B01000000, B01000000, B01000000, B01000000, B01000000, B01000000, B00000000 };
ByteBlock i =  { B00000000, B10000000, B00000000, B10000000, B10000000, B10000000, B10000000, B00000000 };
ByteBlock K =  { B00000000, B10001000, B10010000, B11100000, B10100000, B10010000, B10001000, B00000000 };
ByteBlock k =  { B00000000, B10000000, B10010000, B10100000, B11000000, B10100000, B10010000, B00000000 };
ByteBlock l =  { B00000000, B10000000, B10000000, B10000000, B10000000, B10000000, B10000000, B00000000 };
ByteBlock M =  { B00000000, B01000100, B01101100, B01010100, B01000100, B01000100, B01000100, B00000000 };
ByteBlock m =  { B00000000, B00000000, B01110110, B01001001, B01001001, B01001001, B01001001, B00000000 };
ByteBlock n =  { B00000000, B00000000, B01110000, B01001000, B01001000, B01001000, B01001000, B00000000 };
ByteBlock p =  { B00000000, B00000000, B11100000, B10001000, B10001000, B10001000, B11100000, B10000000 };
ByteBlock r =  { B00000000, B00000000, B10100000, B11000000, B10000000, B10000000, B10000000, B00000000 };
ByteBlock s =  { B00000000, B00000000, B01110000, B10000000, B01100000, B00010000, B11100000, B00000000 };
ByteBlock t =  { B00000000, B10000000, B11100000, B10000000, B10000000, B10000000, B01100000, B00000000 };
ByteBlock u =  { B00000000, B00000000, B10010000, B10010000, B10010000, B10010000, B01100000, B00000000 };
ByteBlock w =  { B00000000, B00000000, B10001000, B10001000, B10101000, B11011000, B10001000, B00000000 };
ByteBlock LB = { B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000 };
ByteBlock AZ = { B01000000, B01000000, B01000000, B01000000, B01000000, B00000000, B01000000, B00000000 };

ByteBlock Satz[84];
ByteBlock SegmBytes[4];
int SatzSpalte = 0;

// Matrix - Bits invertieren -------------------------------------------------------------------------------
void Bit_Invert () {
  for (int i=0; i<20; i++) {
    for (int j=0; j<4; j++) {
      for (int k=0; k<8; k++) {
        byte Byte = SegmBytes [j][k] ^ 0xff;
        SegmBytes [j][k]= Byte; } 
      lc.displayOnSegment(3-j, SegmBytes[j]);
       } delay (200); }
}

// Bits tauschen -------------------------------------------------------------------------------------------
void BitTausch (int Pos, ByteBlock Zeichen) {
  ByteBlock BB;
  for(int i = 0; i < 8; i++) { 
    for(int j = 0; j < 8; j++) {
      bool Bit = bitRead (Zeichen[j],i);
      bitWrite (BB[7-i],j, Bit); } }
   for(int i = 0; i < 8; i++) {
    if (BB [i] != 0) {
      Satz[Pos][i] = BB [i]; 
      SatzSpalte++; } }
}

// Satz scrollen -------------------------------------------------------------------------------------------
void Satz_Scrollen () {

  ByteBlock SgmBlock [4];
  int k;
  byte NeuByte;

  for (int i=0; i<4; i++) {
    for (int j=0; j<8; j++) {
      SegmBytes [i][j]= 0; } }

  for (int Zeichen=0; Zeichen<84; Zeichen++) {
    for (k=0; k<9; k++) {

      if (k < 8) { 
        NeuByte = Satz [Zeichen][k];
        if (Satz [Zeichen][k] == 0) { NeuByte = 0; } }
      if ((NeuByte != 0) or (k == 8)) {
        if (k == 8) { NeuByte = 0; }
          
          for (int Segment=0; Segment<4; Segment++) { 
            lc.makeColumns (SegmBytes [Segment], &SgmBlock [Segment]); }  
          for (int Segment=0; Segment<4; Segment++) {
            for (int i=7; i>0; i--) { SgmBlock [Segment][i] = SgmBlock [Segment][i-1]; }      
             if (Segment<3) { SgmBlock [Segment][0] = SgmBlock [Segment + 1][7]; } }
          SgmBlock [3][0] = NeuByte;

          for (int Segment=0; Segment<4; Segment++) { 
            lc.makeColumns (SgmBlock [Segment], &SegmBytes [Segment]); 
            lc.displayOnSegment(3-Segment, SegmBytes[Segment]); } } } }
}

// Leds via Zufall ein- und ausschalten ----------------------------------------------------------------------
void LedsOnOff () {
  for (int LedsEinAus=1; LedsEinAus<100; LedsEinAus++) {
    for (int Segment=0; Segment<4; Segment++ ) {
      for ( int j=0; j<8; j++ ) { SegmBytes [Segment][j] = LB[j]; } 
      for ( int k=0; k<30; k++ ) { 
        int Reihe = random (0,8);
        int Pos = random (0,8);
        bitWrite (SegmBytes [Segment][Reihe],Pos, true); }
      lc.displayOnSegment(Segment,SegmBytes[Segment]); } }
}

// SetUp ---------------------------------------------------------------------------------------------------
void setup() {

  BitTausch (0, M);    BitTausch (1, a);    BitTausch (2, m);    BitTausch (3, a);
  BitTausch (4, AZ);   BitTausch (5, LB);   BitTausch (6, LB);   BitTausch (7, LB);
  BitTausch (8, I);    BitTausch (9, c);    BitTausch (10, h);   BitTausch (11, LB);   
  BitTausch (12, LB);  BitTausch (13, w);   BitTausch (14, i);   BitTausch (15, l);   
  BitTausch (16, l);   BitTausch (17, LB);  BitTausch (18, LB);  BitTausch (19, n);
  BitTausch (20, i);   BitTausch (21, c);   BitTausch (22, h);   BitTausch (23, t);
  BitTausch (24, LB);  BitTausch (25, LB);  BitTausch (26, n);   BitTausch (27, a); 
  BitTausch (28, c);   BitTausch (29, h);   BitTausch (30, LB);  BitTausch (31, LB);
  BitTausch (32, A);   BitTausch (33, m);   BitTausch (34, e);   BitTausch (35, r);
  BitTausch (36, i);   BitTausch (37, k);   BitTausch (38, a);   BitTausch (39, AZ);
  BitTausch (40, LB);  BitTausch (41, LB);  BitTausch (42, H);   BitTausch (43, a);
  BitTausch (44, l);   BitTausch (45, t);   BitTausch (46, LB);  BitTausch (47, LB);
  BitTausch (48, d);   BitTausch (49, i);   BitTausch (50, e);   BitTausch (51, LB);
  BitTausch (52, LB);  BitTausch (53, K);   BitTausch (54, l);   BitTausch (55, a); 
  BitTausch (56, p);   BitTausch (57, p);   BitTausch (58, e);   BitTausch (59, LB);
  BitTausch (60, LB);  BitTausch (61, u);   BitTausch (62, n);   BitTausch (63, d);
  BitTausch (64, LB);  BitTausch (65, LB);  BitTausch (66, s);   BitTausch (67, c);
  BitTausch (68, h);   BitTausch (69, w);   BitTausch (70, i);   BitTausch (71, m);
  BitTausch (72, m);   BitTausch (73, LB);  BitTausch (74, LB);  BitTausch (75, w);
  BitTausch (76, e);   BitTausch (77, i);   BitTausch (78, t);   BitTausch (79, e);
  BitTausch (80, r);   BitTausch (81, LB);  BitTausch (82, LB);  BitTausch (83, AZ);  
  BitTausch (84, LB);
}

// HAUPRPROGRAMM ---------------------------------------------------------------------------------------------
void loop() {

    lc.setIntensity(5);
    LedsOnOff ();
    Satz_Scrollen ();
    delay(500);
    Bit_Invert ();
    delay (500);
}      
// *************************************************************

Kurzvideo

Kurzvideo (Laufschrift)