.. note::

    ¡Hola! Bienvenido a la comunidad de entusiastas de SunFounder Raspberry Pi, Arduino y ESP32 en Facebook. Sumérgete en el mundo de Raspberry Pi, Arduino y ESP32 con otros entusiastas.

    **¿Por qué unirte?**

    - **Soporte Experto**: Resuelve problemas postventa y desafíos técnicos con la ayuda de nuestra comunidad y equipo.
    - **Aprende y Comparte**: Intercambia consejos y tutoriales para mejorar tus habilidades.
    - **Preestrenos Exclusivos**: Accede anticipadamente a anuncios de nuevos productos y adelantos.
    - **Descuentos Especiales**: Disfruta de descuentos exclusivos en nuestros productos más recientes.
    - **Promociones y Sorteos Festivos**: Participa en sorteos y promociones de temporada.

    👉 ¿Listo para explorar y crear con nosotros? Haz clic en [|link_sf_facebook|] y únete hoy mismo!

.. _1.1.6_c:

1.1.6 Módulo de Matriz de LED
==================================

Introducción
--------------------

En este proyecto, aprenderás sobre el Módulo de Matriz de LED. Este módulo utiliza el controlador MAX7219 para manejar la matriz de LED de 8 x 8.

Componentes Necesarios
------------------------------

En este proyecto, necesitamos los siguientes componentes.

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

Es definitivamente conveniente comprar un kit completo, aquí tienes el enlace:

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

    *   - Nombre	
        - ELEMENTOS EN ESTE KIT
        - ENLACE
    *   - Kit Raphael
        - 337
        - |link_Raphael_kit|

También puedes comprarlos por separado en los enlaces a continuación.

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

    *   - INTRODUCCIÓN DEL COMPONENTE
        - ENLACE DE COMPRA

    *   - :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|

Diagrama Esquemático
-----------------------

============== ======== ======== ====
Nombre T-Board físico   wiringPi BCM
SPIMOSI        Pin 19   12       MOSI
SPICE0         Pin 24   10       CE0
SPISCLK        Pin 23   14       SCLK
============== ======== ======== ====

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

Procedimientos Experimentales
-------------------------------

**Paso 1:** Construir el circuito.

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

**Paso 2:** Activa el SPI antes de comenzar el experimento, consulta :ref:`spi_configuration` para más detalles.

**Paso 3:** Ve a la carpeta del código.

.. raw:: html

   <run></run>

.. code-block:: 

    cd ~/raphael-kit/c/1.1.6/

**Paso 4:** Compila el código.

.. raw:: html

   <run></run>

.. code-block:: 

    make

**Paso 5:** Ejecuta el archivo ejecutable.

.. raw:: html

   <run></run>

.. code-block:: 

    sudo ./1.1.6_LedMatrix

Después de ejecutar el código, la matriz de LED muestra en secuencia un cuadrado, un corazón y los números del 0 al 9.

.. note::

    Si no funciona después de ejecutarlo, o aparece un mensaje de error: \"wiringPi.h: No such file or directory\", por favor consulta :ref:`install_wiringpi`.


**Código**

.. 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;
    }


**Análisis de Código**

#. Archivos de Cabecera:

   * ``wiringPi.h``: Proporciona funciones para el control de GPIO.
   * ``wiringPiSPI.h``: Proporciona funciones para la comunicación SPI.
   * ``stdio.h``: Biblioteca estándar de entrada/salida para funciones como printf.

#. Definiciones:

   * ``SPI_CHANNEL``: Especifica el canal SPI (0 o 1) utilizado para la comunicación.
   * ``SPI_SPEED``: Establece la velocidad de comunicación SPI a 1 MHz.

   .. code-block:: c

        #define SPI_CHANNEL    0           // Define el canal SPI (0 o 1)
        #define SPI_SPEED      1000000     // Velocidad SPI establecida en 1 MHz

#. Función ``max7219_write``: Envía datos a un registro específico del controlador de pantalla MAX7219.

   * ``address``: La dirección del registro a escribir.
   * ``data``: Los datos a escribir en el registro.
   * Crea un buffer que contiene la dirección y los datos.
   * Usa ``wiringPiSPIDataRW`` para enviar el buffer por SPI.

   .. code-block:: c

        void max7219_write(unsigned char address, unsigned char data) {
            unsigned char buffer[2];
            buffer[0] = address;   // Dirección del registro para escribir
            buffer[1] = data;      // Datos para escribir en el registro
            wiringPiSPIDataRW(SPI_CHANNEL, buffer, 2);  // Enviar datos vía SPI
        }

#. Función ``max7219_init``: Inicializa el módulo de pantalla MAX7219 con configuraciones necesarias.

   * Configura el modo de decodificación a "sin decodificación" ya que estamos controlando los LEDs directamente.
   * Ajusta la intensidad (brillo) a un nivel moderado (0x03).
   * Establece el límite de escaneo en 7 para habilitar los 8 dígitos (filas) de la pantalla.
   * Sale del modo de apagado para encender la pantalla.
   * Desactiva el modo de prueba de pantalla.
   * Limpia la pantalla escribiendo 0x00 en todos los registros de dígitos.

   .. code-block:: c

        void max7219_init() {
            max7219_write(0x09, 0x00); // Modo de decodificación: Sin decodificación para dígitos (útil para pantallas de 7 segmentos)
            max7219_write(0x0A, 0x03); // Intensidad: Establecer nivel de brillo (0x00 a 0x0F)
            max7219_write(0x0B, 0x07); // Límite de escaneo: Mostrar dígitos 0-7 (todos los 8 dígitos)
            max7219_write(0x0C, 0x01); // Registro de apagado: Operación normal (no en modo de apagado)
            max7219_write(0x0F, 0x00); // Prueba de pantalla: Operación normal (sin modo de prueba)

            // Limpiar todos los dígitos en la pantalla
            for (int i = 1; i <= 8; i++) {
                max7219_write(i, 0x00); // Escribir 0 en cada registro de dígito
            }
        }

#. Función ``max7219_display``: Actualiza la pantalla con un patrón de 8 bytes dado.

   * ``data``: Un arreglo que contiene el patrón a mostrar.
   * Itera a través de cada una de las 8 filas (dígitos) y escribe los datos correspondientes.

   .. code-block:: c

        void max7219_display(unsigned char *data) {
            for (int i = 1; i <= 8; i++) {
                max7219_write(i, data[i - 1]); // Escribir cada fila del patrón en la pantalla
            }
        }

#. Función ``display_pattern``: Muestra un patrón durante un tiempo específico.

   * ``pattern``: El patrón a mostrar (arreglo de 8 bytes).
   * ``delay_ms``: Duración para mostrar el patrón en milisegundos.
   * Llama a ``max7219_display`` para mostrar el patrón.
   * Usa ``delay`` para esperar durante la duración especificada.

   .. code-block:: c

        void display_pattern(const unsigned char pattern[8], int delay_ms) {
            max7219_display((unsigned char *)pattern); // Mostrar el patrón
            delay(delay_ms);                           // Esperar el tiempo especificado en milisegundos
        }

#. Patrones de Arreglos:

   * Contiene patrones predefinidos para el cuadrado, corazón y números del 0 al 9.
   * Cada patrón es un arreglo de 8 bytes, representando 8 filas de la matriz LED de 8x8.
   * Cada byte usa notación binaria donde cada bit representa un LED (1 para encendido, 0 para apagado).
   
   .. code-block:: c

        const unsigned char patterns[][8] = {
            // Patrón cuadrado
            {
                0b11111111, // Fila 1
                0b10000001, // Fila 2
                0b10000001, // Fila 3
                0b10000001, // Fila 4
                0b10000001, // Fila 5
                0b10000001, // Fila 6
                0b10000001, // Fila 7
                0b11111111  // Fila 8
            },
            ...
            // Número 9
            {
                ...
            },
        };    

#. Función main:

   * Inicializa ``WiringPi`` y la interfaz ``SPI``.
   
     .. code-block:: c

        if (wiringPiSetup() == -1) {
            printf("Error al inicializar WiringPi\n");
            return 1;
        }

        if (wiringPiSPISetup(SPI_CHANNEL, SPI_SPEED) == -1) {
            printf("Error al inicializar SPI\n");
            return 1;
        }
   
   * Llama a ``max7219_init`` para configurar el módulo MAX7219.
   
     .. code-block:: c

        max7219_init();  // Inicializar el módulo MAX7219
      
   * Entra en un bucle infinito para mostrar los patrones continuamente. Muestra cada patrón durante 1 segundo antes de pasar al siguiente.

     .. code-block:: c

        while (1) {
            // Mostrar el patrón cuadrado
            display_pattern(patterns[0], 1000);  // Mostrar durante 1000 milisegundos

            // Mostrar el patrón de corazón
            display_pattern(patterns[1], 1000);

            // Mostrar números del 0 al 9
            for (int i = 2; i <= 11; i++) {
                display_pattern(patterns[i], 1000);
            }
        }

**Comprensión de los Patrones**

* Representación Binaria:

  * Cada patrón se define usando literales binarios (prefijo 0b).
  * Cada byte corresponde a una fila en la matriz LED de 8x8.
  * Cada bit dentro del byte representa una columna (LED) en esa fila.
  * El bit más significativo (a la izquierda) corresponde al primer LED a la izquierda.

* Creación de Patrones Personalizados:

  * Puedes crear nuevos patrones definiendo nuevos arreglos de 8 bytes.
  * Cada patrón puede añadirse al arreglo de patrones.
  * Actualiza el bucle de visualización en main para incluir tus nuevos patrones.

**Ajustes y Personalización**

* Cambiar el Brillo: Modifica el nivel de intensidad en ``max7219_init``:

   .. code-block:: c

        max7219_write(0x0A, brightness_level); // brillo entre 0x00 y 0x0F

* Modificar el Tiempo de Visualización: Cambia el parámetro ``delay_ms`` en las llamadas a ``display_pattern`` para ajustar el tiempo de visualización de cada patrón.

Imagen del Fenómeno
-----------------------

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