C++ SPI MAX7219 Projekte

C++ SPI MAX7219 64-LED-Matrix-Modul

Die 64-LED-Matrix besteht aus 8 LED-Spalten und 8 LED-Reihen, wodurch eine Matrix von 64 LEDs bzw. 64 Pixel erzeugt wird.
Die Kommunikation mit dem MAX7219-Chip erfolgt über die SPI-Schnittstelle. "SPI" steht für eine synchrone serielle Peripherie- Kommunikationsschnittstelle und wird für die Kommunikation über kurze Entfernungen verwendet. Synchron bedeutet, dass die Daten innerhalb eines bestimmten Taktzyklus gesendet und empfangen werden, und seriell bedeutet, dass die Daten seriell, Bit für Bit, gesendet werden.
Es ist möglich, mehrere 64-LED-Matrix Module über die SPI-Schnittstelle mit einander zuverbinden. Dann muss jedoch eine externe Stromversorgung für die zusätzlichen Module verwenden werden.

Programm 1

LED-Matrix Testprogramm

Hardware

Die Hardware für das Testprogramm

1 x NANO V3

1 x 64-LED-Matrix-Modul

Verdrahtung

Programm

C++ LED-Matrix Testprogramm

 /*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: 64-LED-Matrix-Screen-Modul - Testprogramm

**************************************************************************************************
Version: 23.02.2022
**************************************************************************************************
Board: NANO V3
**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************
Librarys
- WiFi.h V0.16.1
**************************************************************************************************

 **************************************************************************************************/


#include <MD_MAX72xx.h >
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 1
#define CLK_PIN 13 // or SCK
#define DATA_PIN 11 // or MOSI
#define CS_PIN 10 // or SS
#define DELAYTIME 100 // in milliseconds
MD_MAX72XX mx = MD_MAX72XX(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
void scrollText(char *p) {
uint8_t charWidth;
uint8_t cBuf[8];
mx.clear();
while (*p != '\0') {
charWidth = mx.getChar(*p++, sizeof(cBuf) / sizeof(cBuf[0]), cBuf);
for (uint8_t i=0; i<=charWidth; i++) {
mx.transform(MD_MAX72XX::TSL);
if (i < charWidth) {
mx.setColumn(0, cBuf[i]);
}
delay(DELAYTIME);
}
}
}
void rows() {
mx.clear();
for (uint8_t row=0; row<ROW_SIZE; row++) {
mx.setRow(row, 0xff);
delay(2*DELAYTIME);
mx.setRow(row, 0x00);
}
}

void columns() {
mx.clear();
for (uint8_t col=0; col<mx.getColumnCount(); col++) {
mx.setColumn(col, 0xff);
delay(DELAYTIME/MAX_DEVICES);
mx.setColumn(col, 0x00);
}
}
void intensity() {
uint8_t row;
mx.clear();
for (int8_t i=0; i<=MAX_INTENSITY; i++) {
mx.control(MD_MAX72XX::INTENSITY, i);
mx.setRow(0, 0xff);
delay(DELAYTIME*10);
}
mx.control(MD_MAX72XX::INTENSITY, 8);
}

void transformation() {
uint8_t arrow[COL_SIZE] = {
0b00001000,
0b00011100,
0b00111110,
0b01111111,
0b00011100,
0b00011100,
0b00111110,
0b00000000 };
MD_MAX72XX::transformType_t
t[] = {
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL, MD_MAX72XX::TSL,
MD_MAX72XX::TFLR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR, MD_MAX72XX::TSR,
MD_MAX72XX::TRC,
MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD,
MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD, MD_MAX72XX::TSD,
MD_MAX72XX::TFUD,
MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU,
MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU, MD_MAX72XX::TSU,
MD_MAX72XX::TINV,
MD_MAX72XX::TRC, MD_MAX72XX::TRC, MD_MAX72XX::TRC, MD_MAX72XX::TRC,
MD_MAX72XX::TINV };
mx.clear();
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);
for (uint8_t j=0; j<mx.getDeviceCount(); j++) {
mx.setBuffer(((j+1)*COL_SIZE)-1, COL_SIZE, arrow);
}

// one tab
mx.control(MD_MAX72XX::UPDATE, MD_MAX72XX::ON);
delay(DELAYTIME);
mx.control(MD_MAX72XX::WRAPAROUND, MD_MAX72XX::ON);
for (uint8_t i=0; i<(sizeof(t)/sizeof(t[0])); i++) {
mx.transform(t[i]);
delay(DELAYTIME*4);
}
mx.control(MD_MAX72XX::WRAPAROUND, MD_MAX72XX::OFF);
}
void showCharset() {
mx.clear();
mx.update(MD_MAX72XX::OFF);
for (uint16_t i=0; i<256; i++) {
mx.clear(0);
mx.setChar(COL_SIZE-1, i);
if (MAX_DEVICES >= 3) {
char hex[3];
sprintf(hex, "%02X", i);
mx.clear(1);
mx.setChar((2*COL_SIZE)-1, hex[1]);
mx.clear(2);
mx.setChar((3*COL_SIZE)-1, hex[0]);
}
mx.update();
delay(DELAYTIME*2);
}
mx.update(MD_MAX72XX::ON);
}

void setup() {
mx.begin();
}
void loop() {
scrollText("Graphics");
rows();
columns();
intensity();
transformation();
showCharset();
delay(3000);
}

RAW code

Programm 2

LED-Matrix Würfel

Hardware

Die Hardware für den Würfel

1 x NANO V3

1 x 64-LED-Matrix-Bildschirm

Verdrahtung

Programm

C++ LED-Matrix Würfel

 /*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: A130 Zufallszahlen auf einer LED Matrix
**************************************************************************************************
Version: 22.02.2022
**************************************************************************************************
Board: NANO

**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************
**************************************************************************************************/
#include <TrueRandom.h>
#include <MD_MAX72xx.h>
#include <MD_Parola.h>
#include <SPI.h>

#define  MAX_DEVICES 1
#define CLK_PIN   13  // or SCK
#define DATA_PIN  11  // or MOSI
#define CS_PIN    10  // or SS

// Hardware SPI connection
MD_Parola P = MD_Parola(CS_PIN, MAX_DEVICES);
#define  DELAYTIME  100  // in milliseconds

void setup() {
  Serial.begin(9600);
  Serial.print("Zufallszahl zwischen 1 und 6: ");
  Serial.print(random(1,7));
  Serial.print("\n");

  Serial.print("Zufallszahl zwischen 1 und 6 mit TrueRandom: ");
  uint8_t rnd = TrueRandom.random(1,7);
  Serial.print(rnd);
  Serial.print("\n");
  P.begin();
  P.print(" ");
  delay(500);
  P.print(rnd);

}

void loop() {
  // put your main code here, to run repeatedly:

}

RAW code

Programm 3

LED-Matrix, Texteingabe über den Seriellen Monitor

Funktion

Über den Seriellen Monitor der Arduino IDE kann der Laufschrift-Test verändert werden

Hardware

Die Hardware

1 x UNO

4 x 64-LED-Matrix

Programm

C++ LED-Matrix Laufschrift editieren

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: MAX72xx mit Texteingabe am seriellen Monitor

**************************************************************************************************
Version: 29.12.2022
**************************************************************************************************
Board: ESP32vn IoT UNO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19

**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/


#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

// set to 1 if we are implementing the user interface pot, switch, etc
#define USE_UI_CONTROL 0

#if USE_UI_CONTROL
#include <MD_UISwitch.h>
#endif

// Turn on debug statements to the serial output
#define DEBUG 0

#if DEBUG
#define PRINT(s, x) { Serial.print(F(s)); Serial.print(x); }
#define PRINTS(x) Serial.print(F(x))
#define PRINTX(x) Serial.println(x, HEX)
#else
#define PRINT(s, x)
#define PRINTS(x)
#define PRINTX(x)
#endif

// Define the number of devices we have in the chain and the hardware interface
// NOTE: These pin numbers will probably not work with your hardware and may
// need to be adapted
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CLK_PIN   13
#define DATA_PIN  11
#define CS_PIN    10

// HARDWARE SPI
MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
// SOFTWARE SPI
//MD_Parola P = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);

// Scrolling parameters
#if USE_UI_CONTROL
const uint8_t SPEED_IN = A5;
const uint8_t DIRECTION_SET = 8;  // 8 change the effect
const uint8_t INVERT_SET = 8;     // 9 change the invert

const uint8_t SPEED_DEADBAND = 5;
#endif // USE_UI_CONTROL

uint8_t scrollSpeed = 25;    // default frame delay value
textEffect_t scrollEffect = PA_SCROLL_LEFT;
textPosition_t scrollAlign = PA_LEFT;
uint16_t scrollPause = 2000; // in milliseconds

// Global message buffers shared by Serial and Scrolling functions
#define  BUF_SIZE  75
char curMessage[BUF_SIZE] = { "" };
char newMessage[BUF_SIZE] = { "Griasdi, gib deinen Text ein!" };
bool newMessageAvailable = true;

#if USE_UI_CONTROL

MD_UISwitch_Digital uiDirection(DIRECTION_SET);
MD_UISwitch_Digital uiInvert(INVERT_SET);

void doUI(void)
{
  // set the speed if it has changed
  {
    int16_t speed = map(analogRead(SPEED_IN), 0, 1023, 10, 150);

    if ((speed >= ((int16_t)P.getSpeed() + SPEED_DEADBAND)) ||
        (speed <= ((int16_t)P.getSpeed() - SPEED_DEADBAND)))
    {
      P.setSpeed(speed);
      scrollSpeed = speed;
      PRINT("\nChanged speed to ", P.getSpeed());
    }
  }

  if (uiDirection.read() == MD_UISwitch::KEY_PRESS) // SCROLL DIRECTION
  {
    PRINTS("\nChanging scroll direction");
    scrollEffect = (scrollEffect == PA_SCROLL_LEFT ? PA_SCROLL_RIGHT : PA_SCROLL_LEFT);
    P.setTextEffect(scrollEffect, scrollEffect);
    P.displayClear();
    P.displayReset();
  }

  if (uiInvert.read() == MD_UISwitch::KEY_PRESS)  // INVERT MODE
  {
    PRINTS("\nChanging invert mode");
    P.setInvert(!P.getInvert());
  }
}
#endif // USE_UI_CONTROL

void readSerial(void)
{
  static char *cp = newMessage;

  while (Serial.available())
  {
    *cp = (char)Serial.read();
    if ((*cp == '\n') || (cp - newMessage >= BUF_SIZE - 2)) // end of message character or full buffer
    {
      *cp = '\0'; // end the string
      // restart the index for next filling spree and flag we have a message waiting
      cp = newMessage;
      newMessageAvailable = true;
    }
    else  // move char pointer to next position
      cp++;
  }
}

void setup()
{
  Serial.begin(115200);
  Serial.print("\n[MAX7229 Scrolling Display]\nGib einen Text f�r die Bildlaufanzeige \nin den seriellen Monitor ein \nund Best�tige mit Senden");

#if USE_UI_CONTROL
  uiDirection.begin();
  uiInvert.begin();
  pinMode(SPEED_IN, INPUT);

  doUI();
#endif // USE_UI_CONTROL

  P.begin();
  P.displayText(curMessage, scrollAlign, scrollSpeed, scrollPause, scrollEffect, scrollEffect);
}

void loop()
{
#if USE_UI_CONTROL
  doUI();
#endif // USE_UI_CONTROL

  if (P.displayAnimate())
  {
    if (newMessageAvailable)
    {
      strcpy(curMessage, newMessage);
      newMessageAvailable = false;
    }
    P.displayReset();
  }
  readSerial();
}

RAW code

Programm 4

LED-Matrix RTC-Uhr

Funktion

Die RTC-Uhr zeigt die Uhrzeit, das Datum, die Temperatur und die rel. Luftfeuchte im Wechsel an.

Hardware

Die Hardware für die RTC-Uhr

1 x UNO

4 x 64-LED-Matrix

1 x DHT11

1 x RTC DS1307

Programm

C++ LED-Matrix RTC-UHR

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: MAX7229 RTC Uhr, DS1307 und DTH11
 * for more examples:
 * https://github.com/MajicDesigns/MD_Parola/tree/main/examples
 * https://github.com/MajicDesigns/MD_MAX72XX/tree/main/examples
**************************************************************************************************
Version: 29.12.2022
**************************************************************************************************
Board: UNO
**************************************************************************************************
Libraries:
https://majicdesigns.github.io/MD_MAX72XX/functions.html
https://github.com/MajicDesigns/MD_MAX72XX/tree/main/examples
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <DHT.h>
#include <SPI.h>
#include <Wire.h>
#include "Font7Seg.h"

// Hardware:
//#define HARDWARE_TYPE MD_MAX72XX::PAROLA_HW
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4 // Anzahl der Displays
#define CLK_PIN    13 // CLK / SCK
#define DATA_PIN   11 // DATA / MOSI
#define CS_PIN     10 // CS / SS
#define SPEED_TIME 75 // Speed
#define PAUSE_TIME  0
#define MAX_MESG   20

// RTC Adresse
#define DS1307_ADDRESS 0x68

// DHT
#define DHTPIN 2
#define DHTTYPE DHT11
#define TIMEDHT 1000

// Variablen
uint8_t wday, mday, month, year;
uint8_t hours, minutes, seconds;

char szTime[9];    // mm:ss\0
char szMesg[MAX_MESG + 1] = "";

float humidity, celsius, fahrenheit;

uint8_t degC[] = { 6, 3, 3, 56, 68, 68, 68 }; // Deg C
uint8_t degF[] = { 6, 3, 3, 124, 20, 20, 4 }; // Deg F

uint8_t clear = 0x00;

uint32_t timerDHT = TIMEDHT;

DHT dht(DHTPIN, DHTTYPE);

// SPI Verbindung
MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);

void beginDS1307()
{
  // RTC Daten
  Wire.beginTransmission(DS1307_ADDRESS);
  Wire.write(clear);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDRESS, 0x07);

  seconds = bcdToDec(Wire.read());
  minutes = bcdToDec(Wire.read());
  hours = bcdToDec(Wire.read() & 0xff);
  wday = bcdToDec(Wire.read());
  mday = bcdToDec(Wire.read());
  month = bcdToDec(Wire.read());
  year = bcdToDec(Wire.read());
}

uint8_t decToBcd(uint8_t value)
{
  return ((value / 10 * 16) + (value % 10));
}

uint8_t bcdToDec(uint8_t value)
{
  return ((value / 16 * 10) + (value % 16));
}

// RTC Zeit
void getTime(char *psz, bool f = true)
{
  sprintf(psz, "%02d%c%02d", hours, (f ? ':' : ' '), minutes);
}

// RTC Datum
void getDate(char *psz)
{
  char  szBuf[10];
  sprintf(psz, "%d %s %04d", mday , mon2str(month, szBuf, sizeof(szBuf) - 1), (year + 2000));
}

// Temperatur
void getTemperature()
{
  // Messzeit abwarten
  if ((millis() - timerDHT) > TIMEDHT) {
    timerDHT = millis();

    // Luftfeuchte
    humidity = dht.readHumidity();

    // Temperatur °C
    celsius = dht.readTemperature();

    // Temperatur °F
    fahrenheit = dht.readTemperature(true);

    // Überprüfe DHT11
    if (isnan(humidity) || isnan(celsius) || isnan(fahrenheit)) {
      Serial.println("DHT11 Sensor Fehler!");
      return;
    }
  }
}

// Abrufen eines Labels von PROGMEM in ein char-Array
char *mon2str(uint8_t mon, char *psz, uint8_t len)
{
  static const __FlashStringHelper* str[] =
  {
    F("Jan"), F("Feb"), F("Mar"), F("Apr"),
    F("Mai"), F("Jun"), F("Jul"), F("Aug"),
    F("Sep"), F("Okt"), F("Nov"), F("Dez")
  };

  strncpy_P(psz, (const char PROGMEM *)str[mon - 1], len);
  psz[len] = '\0';

  return (psz);
}

char *dow2str(uint8_t code, char *psz, uint8_t len)
{
  static const __FlashStringHelper* str[] =
  {
    F("Sonntag"), F("Montag"), F("Dienstag"),
    F("Mittwoch"), F("Donnerstag"), F("Freitag"),
    F("Samstag")
  };

  strncpy_P(psz, (const char PROGMEM *)str[code - 1], len);

  psz[len] = '\0';

  return (psz);
}

void setup(void)
{
  Wire.begin();

  P.begin(2);
  P.setInvert(false);

  P.setZone(0,  MAX_DEVICES - 4, MAX_DEVICES - 1);
  P.setZone(1, MAX_DEVICES - 4, MAX_DEVICES - 1);

  P.displayZoneText(1, szTime, PA_CENTER, SPEED_TIME, PAUSE_TIME, PA_PRINT, PA_NO_EFFECT);
  P.displayZoneText(0, szMesg, PA_CENTER, SPEED_TIME, 0, PA_PRINT , PA_NO_EFFECT);

  P.addChar('$', degC);
  P.addChar('&', degF);

  dht.begin();
}

void loop(void)
{
  static uint32_t lastTime = 0; // Memory (ms)
  static uint8_t  display = 0;  // Current display mode
  static bool flasher = false;  // Seconds passing flasher

  beginDS1307();
  getTemperature();

  P.displayAnimate();

  if (P.getZoneStatus(0))
  {
    switch (display)
    {
    case 0: // Temperatur °C
      P.setPause(0, 1000);
      P.setTextEffect(0, PA_SCROLL_LEFT, PA_SCROLL_UP);
      display++;
      dtostrf(celsius, 3, 1, szMesg);
      strcat(szMesg, "$");

      break;

    case 1: // Luftfeuchte
      P.setTextEffect(0, PA_SCROLL_DOWN, PA_SCROLL_LEFT);
      display++;
      dtostrf(humidity, 3, 0, szMesg);
      strcat(szMesg, "%LF ");

      break;

 case 2: // Uhrzeit
      P.setFont(0, numeric7Seg);
      P.setTextEffect(0, PA_PRINT, PA_NO_EFFECT);
      P.setPause(0, 0);

      if ((millis() - lastTime) >= 1000)
      {
        lastTime = millis();
        getTime(szMesg, flasher);
        flasher = !flasher;
      }

      if ((seconds == 10) || (seconds == 20) || (seconds == 30)|| (seconds == 40)|| (seconds == 50)|| (seconds == 60)) {
        display++;
        P.setTextEffect(0, PA_PRINT, PA_WIPE_CURSOR);
      }


      break;
       delay(3000);
    case 3: // Wochentag
      P.setFont(0, nullptr);
      P.setTextEffect(0, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
      display++;
      dow2str(wday, szMesg, MAX_MESG);

      break;
    default: // Kalender
      P.setTextEffect(0, PA_SCROLL_LEFT, PA_SCROLL_LEFT);
      display = 0;
      getDate(szMesg);

      break;
    }

    P.displayReset(0);
  }
}

Font7Seg.h

RAW code

Aufbau und Verdrahtung der RTC-Uhr

Programm 5

LED-Matrix Effekt Beispiele

Hardware

Die Hardware für die Text Effekt-Beispiele

1 x UNO / NANO

4 x 64-LED-Matrix

Programm

C++ LED-Matrix Text Effekt-Beispiele

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: MAX7210 Text Effekte

**************************************************************************************************
Version: 30.12.2022
**************************************************************************************************
Board: ESP32vn IoT UNO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/
// Include the required Arduino libraries:
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

int i = 0;

textEffect_t texteffect[] =
{
  PA_PRINT,
  PA_SCAN_HORIZ,
  PA_SCROLL_LEFT,
  PA_WIPE,
  PA_SCROLL_UP_LEFT,
  PA_SCROLL_UP,
  PA_OPENING_CURSOR,
  PA_GROW_UP,
  PA_MESH,
  PA_SCROLL_UP_RIGHT,
  PA_BLINDS,
  PA_CLOSING,
  PA_RANDOM,
  PA_GROW_DOWN,
  PA_SCAN_VERT,
  PA_SCROLL_DOWN_LEFT,
  PA_WIPE_CURSOR,
  PA_DISSOLVE,
  PA_OPENING,
  PA_CLOSING_CURSOR,
  PA_SCROLL_DOWN_RIGHT,
  PA_SCROLL_RIGHT,
  PA_SLICE,
  PA_SCROLL_DOWN
};

// Define hardware type, size, and output pins:
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CS_PIN 10

// Create a new instance of the MD_Parola class with hardware SPI connection:
MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);

// Setup for software SPI:
// #define DATA_PIN 2
// #define CLK_PIN 4
// MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);

void setup() {
  myDisplay.begin();
  myDisplay.setIntensity(0);
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.setPause(1000);
  myDisplay.setSpeed(100);
  myDisplay.displayClear();
}

void loop() {
  if (myDisplay.displayAnimate()) {
    if (i < sizeof(texteffect)) {
      i++;
    }
    else {
      i = 0;
    }
    myDisplay.displayText("Hello", myDisplay.getTextAlignment(), myDisplay.getSpeed(), myDisplay.getPause(), texteffect[i], texteffect[i]);
            delay(1000);
    myDisplay.displayReset();
  }
}

RAW code

C++ LED-Matrix scroll Text links/rechts

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: MAX72xx Text Animations scroll Text left right

**************************************************************************************************
Version: 01.07.2023
**************************************************************************************************
Board: NANO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4

#define CLK_PIN   13
#define DATA_PIN  11
#define CS_PIN    10

// Hardware SPI connection
MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
//MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);

int i = 0;

/*
textEffect_t texteffect[] = {
  PA_WIPE,
  PA_WIPE_CURSOR,
  PA_OPENING_CURSOR,
  PA_CLOSING_CURSOR,
  PA_BLINDS,
  PA_MESH,
  PA_OPENING,
  PA_CLOSING,
  PA_SCAN_VERT,
  PA_DISSOLVE,
  PA_RANDOM,
  PA_PRINT,
  PA_SCROLL_RIGHT,
  PA_SCROLL_LEFT,
  PA_GROW_UP,
  PA_GROW_DOWN,
  PA_SCROLL_UP,
  PA_SCROLL_DOWN,
  PA_SCROLL_UP_RIGHT,
  PA_SCROLL_UP_LEFT,
  PA_SCROLL_DOWN_RIGHT,
  PA_SCROLL_DOWN_LEFT,
};
*/
textEffect_t texteffect[] = {

  PA_SCROLL_LEFT,
  PA_SCROLL_RIGHT,
};
void setup() {
  myDisplay.begin();
  myDisplay.setIntensity(5);
  myDisplay.setTextAlignment(PA_CENTER);
  myDisplay.setSpeed(100);
  myDisplay.setPause(1000);
  myDisplay.displayClear();
}

void loop() {

  if (myDisplay.displayAnimate()) {
    if (i < sizeof(texteffect)) {
      i++;
    }
    else {
      i = 0;
    }
    myDisplay.displayText("Hi, i am Robi", myDisplay.getTextAlignment(), myDisplay.getSpeed(), myDisplay.getPause(), texteffect[i], texteffect[i]);
    myDisplay.displayReset();
  }
}

C++ LED-Matrix scroll Text nach links

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: MAX72xx scroll Text left

**************************************************************************************************
Version: 01.07.2023
**************************************************************************************************
Board: NANO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/

#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CLK_PIN   13
#define DATA_PIN  11
#define CS_PIN    10
MD_Parola myDisplay = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);

void setup() {
  myDisplay.begin();
  myDisplay.setIntensity(5);
  myDisplay.displayClear();
  myDisplay.displayScroll("Hi, i am Robi", PA_CENTER, PA_SCROLL_LEFT, 100);
  /*
align - this will align the text. we can use the same align option we used before, i.e. PA_RIGHT, PA_LEFT, and PA_CENTER.
textEffect - sets the direction of scrolling. You can use PA_SCROLL_LEFT, PA_SCROLL_RIGHT, PA_SCROLL_UP, PA_SCROLL_DOWN to scroll from left, right, up, and down respectively.
speed - speed will determine the speed of the effect in milliseconds.
   */
}

void loop()
{
  if (myDisplay.displayAnimate()) {
    myDisplay.displayReset();
  }
}

C++ LED-Matrix statischer Text

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: MAX72xx statischer Text

**************************************************************************************************
Version: 01.07.2023
**************************************************************************************************
Board: NANO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/
#include <MD_Parola.h>
#include <MD_MAX72xx.h>
#include <SPI.h>

const uint16_t WAIT_TIME = 1000;
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CLK_PIN   13
#define DATA_PIN  11
#define CS_PIN    10

MD_Parola P = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);


void setup(void)
{
  P.begin();
}

void loop(void)
{
  P.print("Hello");
  delay(WAIT_TIME);
}

LED Matrix erzeugen

Processing

Mit Processing erstellt man sehr einfach die Matrix für die Programm-Arrays. Die aktiven LEDs werden per Mausklick angewählt, mit "GETCODE" erhält man den HEX-Code, der dann in das C++ Programm kopiert wird. Die einzelnen Ebenen kann man mit den Buchstaben A - T in der obersten Reihe auswählen und die Geschwindigkeit der Bildfolgen ist mit "SPEED" einstellbar. Die Vorschau wird mit "BLINKSHOW" aktiviert.

Programm

C++ LED-Matrix hex Code von LED-Matrix Prozessing

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: MAX72xx Test mit zwei Augenpaaren (hex Code von LED-Matrix Prozessing)

**************************************************************************************************
Version: 30.06.2023
**************************************************************************************************
Board: NANO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/


#include "LedControl.h"

LedControl lc=LedControl(11,13,10,2); //DIN, CLK, CS, Anzahl der Module


//----- Eye 1 ----------------------
void eye_1() {
  byte data_eye_1[] = {
   0x00,0x3C,0x5A,0x5A,0x42,0x42,0x3C,0x00,
};

  for (int i = 0; i < 8; i++) {
    lc.setRow(0,i,data_eye_1[i]); //Eye r
  }
  for (int i = 0; i < 8; i++) {
    lc.setRow(1,i,data_eye_1[i]); //Eye l
  }
}
//------------------------------------


//-------- Eye 2 --------------------
void eye_2() {
 byte data_eye_2[] = {
   0x00,0x3C,0x42,0x42,0x5A,0x5A,0x3C,0x00,
 };

  for (int i = 0; i < 8; i++) {
    lc.setRow(0,i,data_eye_2[i]); //Eye r
  }
    for (int i = 0; i < 8; i++) {
    lc.setRow(1,i,data_eye_2[i]); //Eye l
  }
}
//--------------------------------------

void setup() {
  for(int i=0;i<2;i++){
    lc.shutdown(i,false);
    lc.setIntensity(i,8);
    lc.clearDisplay(i);
  }
}


void loop() {
    eye_1();
  delay(1000);

    eye_2();
  delay(1000);
}

Download LED_Matrix Programm Processing

Programm

C++ LED-Matrix single LED-Ansteuerung

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: 1 x MAX72xx LED-Ansteuerung

**************************************************************************************************
Version: 25.06.2023
**************************************************************************************************
Board: NANO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19

**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/


#include "LedControl.h"
LedControl lc884=LedControl(11,13,10,4);  // DIN, CLK, CS, 4xMAX72xx

unsigned long interval=3000; // the time we need to wait
unsigned long previousMillis=0; // millis() returns an unsigned long.


void setup() {
  for(int i=0;i<2;i++){
    lc884.shutdown(i,false);
    lc884.setIntensity(i,8);
    lc884.clearDisplay(i);
  }
}


void loop() {

  lc884.setRow(0,0,B00000010); // 0x02
  lc884.setRow(0,1,B00000110);
  lc884.setRow(0,2,B00001010);
  lc884.setRow(0,3,B00010010);
  lc884.setRow(0,4,B00101010);
  lc884.setRow(0,5,B01011010);
  lc884.setRow(0,6,B01000010);
  lc884.setRow(0,7,B00111100);


  lc884.setRow(1,0,B01000000);
  lc884.setRow(1,1,B01100000);
  lc884.setRow(1,2,B01010000);
  lc884.setRow(1,3,B01001000);
  lc884.setRow(1,4,B01010100);
  lc884.setRow(1,5,B01011010);
  lc884.setRow(1,6,B01000010);
  lc884.setRow(1,7,B00111100);

/*
   delay(3000);

  lc884.setRow(0,0,B00111100);
  lc884.setRow(0,1,B01000010);
  lc884.setRow(0,2,B01000010);
  lc884.setRow(0,3,B01000010);
  lc884.setRow(0,4,B01011010);
  lc884.setRow(0,5,B01011010);
  lc884.setRow(0,6,B01000010);
  lc884.setRow(0,7,B00111100);

  lc884.setRow(1,0,B00111100);
  lc884.setRow(1,1,B01000010);
  lc884.setRow(1,2,B01000010);
  lc884.setRow(1,3,B01000010);
  lc884.setRow(1,4,B01011010);
  lc884.setRow(1,5,B01011010);
  lc884.setRow(1,6,B01000010);
  lc884.setRow(1,7,B00111100);
  delay(1000);

  */

}

RAW code

C++ SPI MAX7219 64-LED-Matrix-Modul

Programm 1

Hardware

Verdrahtung

Programm

Programm 2

Hardware

Verdrahtung

Programm

Programm 3

Funktion

Hardware

Programm

Programm 4

Funktion

Hardware

Programm

Programm 5

Hardware

Programm

LED Matrix erzeugen

Processing

Programm

NANO PINOUT