Como funciona o Módulo 4 Matrizes de LED 8×8 com MAX7219? Deixe um comentário

Neste post vamos mostrar um display muito interessante para o seu projeto com Arduino, Raspberry Pi, ESP8266 ou ESP32: o Módulo 4 Matrizes de LED 8×8 com Max7219, que vamos usar conectado a uma Placa Uno R3.

Com esse display você pode montar painéis de avisos, alarmes, informações como horário e temperatura e mostrar textos e gráficos de uma maneira muito prática.

O módulo 4 matrizes de led 8×8 com Max7219

O módulo que vamos usar tem todos os componentes em uma única peça, conforme podemos ver na imagem abaixo, com os 4 módulos de display na parte de cima, e se você retirar o display você verá logo embaixo o controlador MAX7219.

São 4 displays de leds 8×8 (64 leds cada), com cada um sendo controlado por um CI MAX7219 (datasheet).

O Max7219 é um CI driver de display muito versátil, e serve perfeitamente para controlar matrizes de led mas também leds de forma individual ou displays 7 segmentos.

Se olharmos a parte de trás do módulo vamos ver as marcações do sentido dos sinais de entrada e alimentação, e como os módulos são interligados:

Ou seja, os mesmos sinais que você vê no lado direito (VCC, GND, DIN, CS, CLK) são compartilhados em todos os segmentos do módulo, e você pode usar esses mesmos sinais nos pinos do lado esquerdo (onde vemos o DIN se “transformar” em DOUT) para interligar mais módulos e assim formar painéis maiores.

Ligando o módulo 4 matrizes na Placa Uno

Conectar o módulo 4 matrizes de led 8×8 com Max7219 no Arduino é muito fácil, já que são apenas 3 pinos de controle (fora os 2 pinos de alimentação, é claro).

Vamos usar então para controle os pinos digitais 5, 6 e 7 da Placa Uno, conectados respectivamente nos pinos DIN, CS e CLK do módulo, como na imagem abaixo:

Para efeito de testes, você pode usar como alimentação do módulo Max7219 os pinos 5V e GND do Arduino, mas se possível recomendo que você use uma fonte externa para não sobrecarregar a Placa Uno.

Instalação das bibliotecas para o módulo MAX7219

Para os programas de exemplo deste post vamos usar as bibliotecas MD_MAX72XX e MD_MAXPanel, disponíveis para instalação através da própria IDE do Arduino.

Na IDE, acesse o menu Sketch -> Incluir bibliotecas – Gerenciar Bibliotecas, e procure por “MD_MAX”. As bibliotecas disponíveis com esse nome serão exibidas automaticamente.

Selecione então as bibliotecas conforme imagem abaixo, clicando em seguida em Instalar:

 

Para garantir que as bibliotecas estejam funcionando normalmente, reinicie a IDE após a instalação.

Programas de teste módulo 4 matrizes de led 8×8 com Max7219

Vamos testar o módulo com dois programas baseados nas bibliotecas instaladas.

O primeiro programa gera uma mensagem simples de texto e permite que você envie uma string pelo Serial Monitor para que esta seja mostrada no display.

Nas linhas 17, 18 e 19 você tem as definições da conexão dos pinos CLK, DIN e CS do módulo, e na linha 14 o número de dispositivos conectados, no nosso caso 4, que correspondem aos 4 displays. Altere esse número se você for interligar módulos MAX7219 em cascata.

//Programa: Texto com Modulo 4 matrizes de led MAX7219
//Autor: Arduino e Cia
//Baseado na biblioteca de exemplo MD_MAX72xx

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

#define PRINT(s, v) { Serial.print(F(s)); Serial.print(v); }

//Define o tipo de hardware conectado
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW

//Define o numero de dispositivos conectados
#define MAX_DEVICES 4

//Pinos de conexao do modulo no Arduino
#define CLK_PIN   7
#define DATA_PIN  5
#define CS_PIN    6

MD_MAX72XX mx = MD_MAX72XX(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);


//Parametros de texto (espaco entre carecteres (em pixels))
#define CHAR_SPACING  1

//Tamanho do buffer de texto
#define BUF_SIZE  75

//Mensagem inicial
char message[BUF_SIZE] = "LEDs...";
bool newMessageAvailable = true;

void readSerial(void)
{
  //Rotina que realiza a leitura dos caracteres digitados no Serial Monitor
  static uint8_t	putIndex = 0;

  while (Serial.available())
  {
    message[putIndex] = (char)Serial.read();
    if ((message[putIndex] == '\n') || (putIndex >= BUF_SIZE - 3)) // end of message character or full buffer
    {
      message[putIndex] = '\0';
      putIndex = 0;
      newMessageAvailable = true;
    }
    else
      message[putIndex++];
  }
}

void printText(uint8_t modStart, uint8_t modEnd, char *pMsg)
//Mostra o texto no display
{
  uint8_t   state = 0;
  uint8_t   curLen;
  uint16_t  showLen;
  uint8_t   cBuf[8];
  int16_t   col = ((modEnd + 1) * COL_SIZE) - 1;

  mx.control(modStart, modEnd, MD_MAX72XX::UPDATE, MD_MAX72XX::OFF);

  do
  {
    switch (state)
    {
      case 0: // Load the next character from the font table
        // if we reached end of message, reset the message pointer
        if (*pMsg == '\0')
        {
          showLen = col - (modEnd * COL_SIZE);  // padding characters
          state = 2;
          break;
        }

        // retrieve the next character form the font file
        showLen = mx.getChar(*pMsg++, sizeof(cBuf) / sizeof(cBuf[0]), cBuf);
        curLen = 0;
        state++;
      // !! deliberately fall through to next state to start displaying

      case 1: // display the next part of the character
        mx.setColumn(col--, cBuf[curLen++]);

        // done with font character, now display the space between chars
        if (curLen == showLen)
        {
          showLen = CHAR_SPACING;
          state = 2;
        }
        break;

      case 2: // initialize state for displaying empty columns
        curLen = 0;
        state++;
      // fall through

      case 3:	// display inter-character spacing or end of message padding (blank columns)
        mx.setColumn(col--, 0);
        curLen++;
        if (curLen == showLen)
          state = 0;
        break;

      default:
        col = -1;   // this definitely ends the do loop
    }
  } while (col >= (modStart * COL_SIZE));

  mx.control(modStart, modEnd, MD_MAX72XX::UPDATE, MD_MAX72XX::ON);
}

void setup()
{
  mx.begin();
  mx.control(MD_MAX72XX::INTENSITY, MAX_INTENSITY / 4);
  Serial.begin(9600);
  Serial.print("\n[Mensagens com modulo MAX7219]\nDigite a mensagem para enviar ao display\nPressione ENTER para enviar");
}

void loop()
{
  readSerial();
  if (newMessageAvailable)
  {
    PRINT("\nProcessando nova mensagem: ", message);
    printText(0, MAX_DEVICES - 1, message);
    newMessageAvailable = false;
  }
}

Após carregar o programa abra o Serial Monitor para que você possa enviar caracteres para o display. Não esqueça de selecionar “Nova-linha” na parte inferior do Serial Monitor:

Digite a palavra e pressione ENTER (ou clique em Enviar) para que esta seja mostrada no display.

O segundo programa cria o efeito de uma bolinha batendo nas laterais do display e mostra o potencial de gerar efeitos gráficos com a biblioteca MD_MAXPanel.

A biblioteca MD_MAXPanel é muito útil se você precisar usar muitos módulos em cascata pois nele você define o número de displays 8×8 na horizontal (X_DEVICES) e o número de módulos na vertical (Y_DEVICES).

Dessa maneira, se você interligar 2 módulos e colocar um na parte superior e um na inferior, as linhas 12 e 13 do programa ficam assim:

const uint8_t X_DEVICES = 4; //Cada módulo tem 4 displays
const uint8_t Y_DEVICES = 2; //2 módulos conectados, 1 na parte superior e 1 na inferior

Como estamos usando apenas um módulo, o nosso programa fica com os valores 4 e 1, respectivamente:

//Programa: Efeito bounce com Modulo 4 matrizes de led MAX7219
//Autor: Arduino e Cia
//Baseado na biblioteca de exemplo MD_MAXPanel
//Para correto funcionamento, instale a biblioteca MD_MAX72XX

#include <MD_MAXPanel.h>

//Define o tipo de hardware conectado
const MD_MAX72XX::moduleType_t HARDWARE_TYPE = MD_MAX72XX::FC16_HW;

//Define o numero de dispositivos conectados
const uint8_t X_DEVICES = 4;
const uint8_t Y_DEVICES = 1;

//Pinos de conexao do modulo no Arduino
const uint8_t CLK_PIN = 7;
const uint8_t DATA_PIN = 5;
const uint8_t CS_PIN = 6;

MD_MAXPanel mp = MD_MAXPanel(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, X_DEVICES, Y_DEVICES);

//Intervalo entre updates do display (em milisegundos)
#define  DELAYTIME  100

void bounce(void)
{
  const uint16_t minX = 0;
  const uint16_t maxX = mp.getXMax();
  const uint16_t minY = 0;
  const uint16_t maxY = mp.getYMax();

  uint16_t  nCounter = 0;

  uint16_t  y = random(maxY / 2) + maxY / 2, x = random(maxX / 2) + maxX / 2;
  int8_t dy = 1, dx = 1;	// delta row and column

  mp.clear();

  while (nCounter++ < 200)
  {
    mp.setPoint(x, y, false);
    x += dx;
    y += dy;
    mp.setPoint(x, y, true);
    delay(DELAYTIME / 2);

    if ((x == minX) || (x == maxX))
      dx = -dx;
    if ((y == minY) || (y == maxY))
      dy = -dy;
  }
}


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

void loop(void)
{
  bounce();
}

Recomendo também carregar os exemplos das bibliotecas MD_MAX72XX e MD_MAXPanel para explorar todo o potencial do módulo.Não se esqueça de alterar as definições dos pinos CS, CLK e DIN nesses programas.

Gostou de conhecer um pouco sobre o Módulo 4 Matrizes de LED 8×8 com MAX7219?

---

Se você tiver dúvidas, sugestões ou experiências para compartilhar, fique a vontade para deixar um comentário abaixo. E para não perder nenhum conteúdo como este, não deixe de nos seguir no Instagram.