.. note::

    Hallo und willkommen in der SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasten-Gemeinschaft auf Facebook! Tauchen Sie tiefer ein in die Welt von Raspberry Pi, Arduino und ESP32 mit anderen Enthusiasten.

    **Warum beitreten?**

    - **Expertenunterstützung**: Lösen Sie Nachverkaufsprobleme und technische Herausforderungen mit Hilfe unserer Gemeinschaft und unseres Teams.
    - **Lernen & Teilen**: Tauschen Sie Tipps und Anleitungen aus, um Ihre Fähigkeiten zu verbessern.
    - **Exklusive Vorschauen**: Erhalten Sie frühzeitigen Zugang zu neuen Produktankündigungen und exklusiven Einblicken.
    - **Spezialrabatte**: Genießen Sie exklusive Rabatte auf unsere neuesten Produkte.
    - **Festliche Aktionen und Gewinnspiele**: Nehmen Sie an Gewinnspielen und Feiertagsaktionen teil.

    👉 Sind Sie bereit, mit uns zu erkunden und zu erschaffen? Klicken Sie auf [|link_sf_facebook|] und treten Sie heute bei!

.. _1.1.6_c:

1.1.6 LED Dot Matrix Modul
==================================

Einführung
--------------------

In diesem Projekt werden Sie das LED Matrix Modul kennenlernen. Das LED Matrix Modul verwendet den MAX7219 Treiber, um die 8 x 8 LED Matrix zu steuern.

Benötigte Komponenten
------------------------------

Für dieses Projekt benötigen wir die folgenden Komponenten. 

.. image:: ../img/list_dot.png

Es ist definitiv praktisch, ein ganzes Kit zu kaufen. Hier ist der Link:

.. list-table::
    :widths: 20 20 20
    :header-rows: 1

    *   - Name	
        - ARTIKEL IN DIESEM KIT
        - LINK
    *   - Raphael Kit
        - 337
        - |link_Raphael_kit|

Sie können sie auch separat über die untenstehenden Links kaufen.

.. list-table::
    :widths: 30 20
    :header-rows: 1

    *   - KOMPONENTENBESCHREIBUNG
        - KAUF-LINK

    *   - :ref:`cpn_gpio_board`
        - |link_gpio_board_buy|
    *   - :ref:`cpn_breadboard`
        - |link_breadboard_buy|
    *   - :ref:`cpn_wires`
        - |link_wires_buy|
    *   - :ref:`cpn_dot_matrix`
        - |link_led_matrix_buy|

Schaltplan
-----------------------

============ ======== ======== ====
T-Board Name physical wiringPi BCM
SPIMOSI      Pin 19   12       MOSI
SPICE0       pin 24   10       CE0
SPISCLK      Pin 23   14       SCLK
============ ======== ======== ====

.. image:: ../img/schematic_dot.png

Experimentelle Verfahren
----------------------------

**Schritt 1:** Bauen Sie die Schaltung. 

.. image:: ../img/1.1.6fritzing.png

**Schritt 2:** Schalten Sie das SPI vor Beginn des Experiments ein. Siehe :ref:`spi_configuration` für Details. 

**Schritt 3:** Navigieren Sie zum Ordner des Codes.

.. raw:: html

   <run></run>

.. code-block:: 

    cd ~/raphael-kit/c/1.1.6/

**Schritt 4:** Kompilieren Sie den Code.

.. raw:: html

   <run></run>

.. code-block:: 

    make

**Schritt 5:** Starten Sie die ausführbare Datei.

.. raw:: html

   <run></run>

.. code-block:: 

    sudo ./1.1.6_LedMatrix

Nach dem Ausführen des Codes zeigt die LED-Punktmatrix nacheinander ein Quadrat, ein Herz und die Zahlen 0 bis 9 an.

.. note::

    Wenn es nach dem Start nicht funktioniert oder eine Fehlermeldung erscheint: \"wiringPi.h: No such file or directory\", bitte beziehen Sie sich auf :ref:`install_wiringpi`.

**Code**

.. code-block:: c

    #include <wiringPi.h>
    #include <wiringPiSPI.h>
    #include <stdio.h>

    #define SPI_CHANNEL    0           // Define SPI channel (0 or 1)
    #define SPI_SPEED      1000000     // SPI speed set to 1 MHz

    // Function to write data to a MAX7219 register
    void max7219_write(unsigned char address, unsigned char data) {
        unsigned char buffer[2];
        buffer[0] = address;   // Register address to write to
        buffer[1] = data;      // Data to write into the register
        wiringPiSPIDataRW(SPI_CHANNEL, buffer, 2);  // Send data via SPI
    }

    // Function to initialize the MAX7219 display module
    void max7219_init() {
        max7219_write(0x09, 0x00); // Decode Mode: No decoding for digits (useful for 7-segment displays)
        max7219_write(0x0A, 0x03); // Intensity: Set brightness level (0x00 to 0x0F)
        max7219_write(0x0B, 0x07); // Scan Limit: Display digits 0-7 (all 8 digits)
        max7219_write(0x0C, 0x01); // Shutdown Register: Normal operation (not in shutdown mode)
        max7219_write(0x0F, 0x00); // Display Test: Normal operation (no test mode)

        // Clear all digits on the display
        for (int i = 1; i <= 8; i++) {
            max7219_write(i, 0x00); // Write 0 to each digit register
        }
    }

    // Function to display a pattern on the MAX7219
    void max7219_display(unsigned char *data) {
        for (int i = 1; i <= 8; i++) {
            max7219_write(i, data[i - 1]); // Write each row of the pattern to the display
        }
    }

    // Function to display a pattern for a specified duration
    void display_pattern(const unsigned char pattern[8], int delay_ms) {
        max7219_display((unsigned char *)pattern); // Display the pattern
        delay(delay_ms);                           // Wait for the specified time in milliseconds
    }

    // Array of patterns to display
    const unsigned char patterns[][8] = {
        // Square pattern
        {
            0b11111111, // Row 1
            0b10000001, // Row 2
            0b10000001, // Row 3
            0b10000001, // Row 4
            0b10000001, // Row 5
            0b10000001, // Row 6
            0b10000001, // Row 7
            0b11111111  // Row 8
        },
        // Heart pattern
        {
            0b01100110, // Row 1
            0b11111111, // Row 2
            0b11111111, // Row 3
            0b11111111, // Row 4
            0b01111110, // Row 5
            0b00111100, // Row 6
            0b00011000, // Row 7
            0b00000000  // Row 8
        },
        // Number 0
        {
            0b00111100, // Row 1
            0b01100110, // Row 2
            0b11000011, // Row 3
            0b11000011, // Row 4
            0b11000011, // Row 5
            0b11000011, // Row 6
            0b01100110, // Row 7
            0b00111100  // Row 8
        },
        // Number 1
        {
            0b00011000, // Row 1
            0b00111000, // Row 2
            0b01111000, // Row 3
            0b00011000, // Row 4
            0b00011000, // Row 5
            0b00011000, // Row 6
            0b01111110, // Row 7
            0b01111110  // Row 8
        },
        // Number 2
        {
            0b01111110, // Row 1
            0b11000011, // Row 2
            0b00000011, // Row 3
            0b00001110, // Row 4
            0b00110000, // Row 5
            0b11000000, // Row 6
            0b11111111, // Row 7
            0b00000000  // Row 8
        },
        // Number 3
        {
            0b01111110, // Row 1
            0b11000011, // Row 2
            0b00000011, // Row 3
            0b00111110, // Row 4
            0b00000011, // Row 5
            0b11000011, // Row 6
            0b01111110, // Row 7
            0b00000000  // Row 8
        },
        // Number 4
        {
            0b00001110, // Row 1
            0b00011110, // Row 2
            0b00110110, // Row 3
            0b01100110, // Row 4
            0b11111111, // Row 5
            0b00000110, // Row 6
            0b00000110, // Row 7
            0b00000000  // Row 8
        },
        // Number 5
        {
            0b11111111, // Row 1
            0b11000000, // Row 2
            0b11111110, // Row 3
            0b00000011, // Row 4
            0b00000011, // Row 5
            0b11000011, // Row 6
            0b01111110, // Row 7
            0b00000000  // Row 8
        },
        // Number 6
        {
            0b00111110, // Row 1
            0b01100000, // Row 2
            0b11000000, // Row 3
            0b11111110, // Row 4
            0b11000011, // Row 5
            0b11000011, // Row 6
            0b01111110, // Row 7
            0b00000000  // Row 8
        },
        // Number 7
        {
            0b11111111, // Row 1
            0b11000011, // Row 2
            0b00000110, // Row 3
            0b00001100, // Row 4
            0b00011000, // Row 5
            0b00110000, // Row 6
            0b00110000, // Row 7
            0b00000000  // Row 8
        },
        // Number 8
        {
            0b01111110, // Row 1
            0b11000011, // Row 2
            0b11000011, // Row 3
            0b01111110, // Row 4
            0b11000011, // Row 5
            0b11000011, // Row 6
            0b01111110, // Row 7
            0b00000000  // Row 8
        },
        // Number 9
        {
            0b01111110, // Row 1
            0b11000011, // Row 2
            0b11000011, // Row 3
            0b01111111, // Row 4
            0b00000011, // Row 5
            0b00000110, // Row 6
            0b01111100, // Row 7
            0b00000000  // Row 8
        },
    };

    int main() {
        if (wiringPiSetup() == -1) {
            printf("Failed to initialize WiringPi\n");
            return 1;
        }

        if (wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1) {
            printf("Failed to initialize SPI\n");
            return 1;
        }

        max7219_init();  // Initialize the MAX7219 module

        // Display patterns in a loop
        while (1) {
            // Display the square pattern
            display_pattern(patterns[0], 1000);  // Display for 1000 milliseconds

            // Display the heart pattern
            display_pattern(patterns[1], 1000);

            // Display numbers 0-9
            for (int i = 2; i <= 11; i++) {
                display_pattern(patterns[i], 1000);
            }
        }

        return 0;
    }

**Code-Analyse**

#. Header-Dateien:

   * ``wiringPi.h``: Bietet Funktionen zur Steuerung der GPIO-Schnittstellen.
   * ``wiringPiSPI.h``: Bietet Funktionen für die SPI-Kommunikation.
   * ``stdio.h``: Standard-Ein-/Ausgabe-Bibliothek für Funktionen wie printf.

#. Definitionen:

   * ``SPI_CHANNEL``: Legt den verwendeten SPI-Kanal (0 oder 1) für die Kommunikation fest.
   * ``SPI_SPEED``: Setzt die SPI-Kommunikationsgeschwindigkeit auf 1 MHz.

   .. code-block:: c

        #define SPI_CHANNEL    0           // Definiere den SPI-Kanal (0 oder 1)
        #define SPI_SPEED      1000000     // SPI-Geschwindigkeit auf 1 MHz gesetzt

#. Funktion ``max7219_write``: Sendet Daten an ein bestimmtes Register des MAX7219-Anzeigetreibers.

   * ``address``: Die Adresse des Registers, an das geschrieben werden soll.
   * ``data``: Die zu schreibenden Daten in das Register.
   * Erstellt einen Puffer, der die Adresse und Daten enthält.
   * Verwendet ``wiringPiSPIDataRW``, um den Puffer über SPI zu senden.

   .. code-block:: c

        void max7219_write(unsigned char address, unsigned char data) {
            unsigned char buffer[2];
            buffer[0] = address;   // Registeradresse, an die geschrieben werden soll
            buffer[1] = data;      // Daten, die in das Register geschrieben werden
            wiringPiSPIDataRW(SPI_CHANNEL, buffer, 2);  // Daten über SPI senden
        }

#. Funktion ``max7219_init``: Initialisiert das MAX7219-Display-Modul mit den erforderlichen Einstellungen.

   * Setzt den Decode-Modus auf „No Decode“, da wir die LEDs direkt steuern.
   * Setzt die Intensität (Helligkeit) auf ein moderates Niveau (0x03).
   * Setzt das Scan-Limit auf 7, um alle 8 Stellen (Reihen) des Displays zu aktivieren.
   * Beendet den Shutdown-Modus, um das Display einzuschalten.
   * Deaktiviert den Display-Testmodus.
   * Löscht das Display, indem 0x00 an alle Stellen-Register geschrieben wird.

   .. code-block:: c

        void max7219_init() {
            max7219_write(0x09, 0x00); // Decode-Modus: Kein Decode für Ziffern (nützlich für 7-Segment-Displays)
            max7219_write(0x0A, 0x03); // Intensität: Helligkeitsstufe einstellen (0x00 bis 0x0F)
            max7219_write(0x0B, 0x07); // Scan-Limit: Zeigt Ziffern 0-7 (alle 8 Ziffern) an
            max7219_write(0x0C, 0x01); // Shutdown-Register: Normalbetrieb (nicht im Shutdown-Modus)
            max7219_write(0x0F, 0x00); // Display-Test: Normalbetrieb (kein Testmodus)

            // Löscht alle Ziffern auf dem Display
            for (int i = 1; i <= 8; i++) {
                max7219_write(i, 0x00); // Schreibt 0 in jedes Stellen-Register
            }
        }

#. Funktion ``max7219_display``: Aktualisiert das Display mit einem gegebenen 8-Byte-Muster.

   * ``data``: Ein Array, das das anzuzeigende Muster enthält.
   * Durchläuft jede der 8 Reihen (Ziffern) und schreibt die entsprechenden Daten.

   .. code-block:: c

        void max7219_display(unsigned char *data) {
            for (int i = 1; i <= 8; i++) {
                max7219_write(i, data[i - 1]); // Schreibt jede Reihe des Musters auf das Display
            }
        }

#. Funktion ``display_pattern``: Zeigt ein Muster für eine bestimmte Zeitdauer an.

   * ``pattern``: Das anzuzeigende Muster (Array von 8 Bytes).
   * ``delay_ms``: Dauer der Anzeige des Musters in Millisekunden.
   * Ruft ``max7219_display`` auf, um das Muster anzuzeigen.
   * Verwendet ``delay``, um die angegebene Zeit abzuwarten.

   .. code-block:: c

        void display_pattern(const unsigned char pattern[8], int delay_ms) {
            max7219_display((unsigned char *)pattern); // Zeigt das Muster an
            delay(delay_ms);                           // Warten für die angegebene Zeit in Millisekunden
        }

#. Array-Muster:

   * Enthält vordefinierte Muster für das Quadrat, Herz und die Zahlen 0-9.
   * Jedes Muster ist ein Array von 8 Bytes und stellt 8 Reihen der 8x8-LED-Matrix dar.
   * Jedes Byte verwendet die Binärnotation, wobei jedes Bit eine LED darstellt (1 für ein, 0 für aus).

   .. code-block:: c

        const unsigned char patterns[][8] = {
            // Quadrat-Muster
            {
                0b11111111, // Reihe 1
                0b10000001, // Reihe 2
                0b10000001, // Reihe 3
                0b10000001, // Reihe 4
                0b10000001, // Reihe 5
                0b10000001, // Reihe 6
                0b10000001, // Reihe 7
                0b11111111  // Reihe 8
            },
            ...
            // Zahl 9
            {
                ...
            },
        };    

#. Funktion main:

   * Initialisiert ``WiringPi`` und die ``SPI``-Schnittstelle.
   
     .. code-block:: c

        if (wiringPiSetup() == -1) {
            printf("Fehler bei der Initialisierung von WiringPi\n");
            return 1;
        }

        if (wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1) {
            printf("Fehler bei der Initialisierung von SPI\n");
            return 1;
        }
   
   * Ruft ``max7219_init`` auf, um das MAX7219-Modul zu konfigurieren.
   
     .. code-block:: c

        max7219_init();  // Initialisiert das MAX7219-Modul
      
   * Betritt eine Endlosschleife, um die Muster kontinuierlich anzuzeigen. Zeigt jedes Muster 1 Sekunde lang an, bevor zum nächsten gewechselt wird.

     .. code-block:: c

        while (1) {
            // Zeigt das Quadrat-Muster an
            display_pattern(patterns[0], 1000);  // Anzeige für 1000 Millisekunden

            // Zeigt das Herz-Muster an
            display_pattern(patterns[1], 1000);

            // Zeigt die Zahlen 0-9 an
            for (int i = 2; i <= 11; i++) {
                display_pattern(patterns[i], 1000);
            }
        }

**Verständnis der Muster**

* Binäre Darstellung:

  * Jedes Muster wird mit Binärliteralen (0b-Präfix) definiert.
  * Jedes Byte entspricht einer Reihe auf der 8x8-LED-Matrix.
  * Jedes Bit im Byte stellt eine Spalte (LED) in dieser Reihe dar.
  * Das höchstwertige Bit (links) entspricht der ersten LED links.

* Erstellen benutzerdefinierter Muster:

  * Sie können neue Muster erstellen, indem Sie neue Arrays von 8 Bytes definieren.
  * Jedes Muster kann dem patterns-Array hinzugefügt werden.
  * Aktualisieren Sie die Anzeigeschleife in main, um Ihre neuen Muster einzuschließen.


**Anpassungen und Anpassbarkeit**

* Ändern der Helligkeit: Passen Sie den Intensitätswert in ``max7219_init`` an:

  .. code-block:: c

        max7219_write(0x0A, brightness_level); // brightness_level zwischen 0x00 und 0x0F

* Anpassung der Anzeigedauer: Ändern Sie den Parameter ``delay_ms`` in den ``display_pattern`` - Aufrufen, um die Dauer der Anzeige jedes Musters anzupassen.

Phänomen-Bild
--------------------

.. image:: ../img/1.1.6led_dot_matrix.JPG