Pular para o conteúdo

Uma aplicação bastante imediata que pode ser utiliza em soluções de sinalização visual, é um letreiro composto de matrizes de LEDs. Há displays com arranjo de 8 x 8 LEDs no mercado e, convenientemente, um circuito integrado capaz de efetuar o controle desses displays, o MAX7219 ou MAX7221 da Maxim.


Não há uma solução mecânica imediata para compor letreiros facilmente encontrada no comércio, aqueles que dispõem de, ou ao menos têm aceso a, uma impressora 3D, podem criar a mecânica necessária para abrigar os módulos pré-montados com os displays de matriz de LEDs e o MAX7219, assim a criatividade maker tem de entrar em ação na maioria das vezes.

Como muitas das publicações aqui do Blá do Chico são eminentemente teóricas ou didáticas, para variar uma publicação com caráter prático vem bem a calhar para quebrar esse formalismo todo.

Vamos ver primeiro o módulo de matriz de LEDs a ser usado...

Na parte inferior existe o conector de entrada de controle que conta com cinco pinos: VCC, GND, Din (Data Input); CS (Chip Select); e CLK (Clock), na parte superior o conector de saída de controle com os mesmo sinais, exceto o Dout (Data Out) ao invés do Din. O módulo tem como componente central o MAX7219 que pode ser conectado ao controlador por um barramento SPI (não 100% compatível, porém operativo). Os capacitores são para melhorar a condição de flutuação da alimentação devido ao chaveamento dos 64 LEDs da matriz (não montada na imagem). O resistor de 10kohm regula a intensidade de corrente fornecida para os diversos LEDs individualmente. Em suma é um módulo bastante simples e que pode ser ligado em “cascata” com outros módulos iguais (normalmente não mais que 8 deles).

Os módulos devem ser arranjados lado a lado para dar continuidade ao deslocamento do texto que for exibido, como ilustra a imagem a seguir.

Por comodidade usaremos apenas três módulos de matriz de LEDs em nossa montagem.

Para fixa-los de forma muito, muito barata foi utilizado um material bastante não convencional para essa finalidade, palitos de sorvete (como os usado em trabalhos manuais) que se compra aos centos por algo como R$ 5,00 em papelarias ou lojas de artesanato.

Mais a diante será mostrada a solução mecânica aplicada, mas antes vejamos a lista de materiais utilizados:

 1 Arduino UNO R3
 3 Módulos Matriz de LED 8x8 com MAX7219
 6 Parafusos M2,5 x 8
 6 Parafusos M2,5 x 16
18 Porcas M2,5
 3 Cabos multi-vias com cinco vias e conectores Dupont fêmea em
   todas as terminações
 4 Palitos de sorvete de 10,5 x 1 cm

Segue ilustração com todo o material acima relacionado a ser utilizado na montagem. No entanto, será necessário também ter disponível um cabo USB com conectores machos A e B em cada extremidade além de um microcomputador com a IDE do Arduino instalada para efetuar a programação do mesmo.

Vamos ao preparo da mecânica “criativa” para nossa montagem.

A planta mais abaixo mostra as dimensões de corte e furação dos palitos de sorvete que deve ser providenciada.

Será muito prático efetuar a furação toda de uma só vez arranjando os palitos em um sanduíche com os quatro palitos, seguros por grampos de carpinteiro (de dimensões adequadas ao material). São seis furos feitos com broca de três milímetros, de forma que a eventual imprecisão seja compensada pela dimensão a maior de 0,5 mm no diâmetro de cada conjunto de furos.

Após a furação dois dos palitos serão cortados em quatro partes como mostrado na planta e depois de dado o acabamento necessário, serão então montados dois suportes, cada um como o mostrado na ilustração a seguir.

Este arranjo foi planejado de tal forma que o palito segmentado sirva de espaçador para que os pontos de solda dos módulos, não toquem o palito base, para não causar torções neste.

Os segmento são colados ao palito base com cola de madeira ou cola instantânea (se utilizar esta última tome precauções para não colar parte de seu corpo ou roupa e muito cuidado com os olhos, o uso de óculo de proteção é fundamental) utilizando os furos como guia de posicionamento.

Na furação superior dos módulo os parafusos de 16 mm de comprimento dever ser fixados previamente inserindo os parafusos pelo lado dos componentes e com um porca em cada, como mostrado na sequência.

Será necessário retirar os displays de matriz de LEDs dos módulos para inserir os parafusos. Após haver inserido e fixado os parafusos de cada módulo, remonte o display de matriz de LEDs. É necessário observar o correto posicionamento do display, sob pena de não funcionamento caso o mesmo seja remontado em posição invertida.

Agora módulo a módulo, iniciando preferencialmente por uma extremidade de arranjo, colocamos os parafusos de 8 mm de comprimento, da face dos componentes do módulo para encaixar um dos suportes, lembrando que os segmentos de palitos espaçadores ficam voltado para a face de solda do módulo e após o suporte uma porca em cada parafuso fixando o módulo ao suporte.

Nesta altura não é necessário, nem recomendável dar aperto, apenas rosqueie manualmente o as porcas nos parafusos até encostarem no suporte.

A figura a seguir mostra como fica a montagem até esta etapa.

Repita estes passos para prender todos os módulos ao suporte inferior.

Agora encaixe o suporte superior nos módulos.

A seguir coloque as porcas nos seis parafusos e verifique que os módulos estão bem acomodados e encaixados e só então de o aperto final nas porcas.

O aperto apropriado é tal que após alcançado o encostamento firme das porcas nos suporte de 1/8 a ¼ de volta adicional é suficiente.

Opcionalmente, para garantir o travamento das porcas, uma pincelada de verniz, ou esmalte, na rosca dos parafusos junto às porcas é uma opção bastante funcional e efetiva.

Após a montagem mecânica, inicia-se a montagem elétrica, pelos cabos de interligação dos módulos, como ilustrado a seguir.

Por fim efetua-se a conexão do módulo da extremidade direita ao Arduino.

Usaremos para tanto o conetor ICSP, conectando o pino 3 do ICSP (Saída digital 13 do Arduino) ao pino CLK do módulo, o pino 2 do ICSP ao VCC do módulo, pino 4 do ICSP (Saída digital 11 do Arduino) ao pino DIN do módulo, e o pino 6 do ICSP ao GND do módulo. O pino CS do módulo deve ser conectado à saída digital 9 do Arduino.

Note que estas conexões são baseadas no código de programação que foi escrita para esta montagem e os pinos DIN, CLK e CS podem ser alterados desde que as mudanças devidas sejam providas no código do Sketch.

A seguir é uma boa ideia verificar o código do sketch e mesmo carrega-lo no IDE do Arduino para verificar se há erros de sintaxe no código.

/*********************************************************************/
/* MAX7219 LED dot matrix test sketch
 * Displays text via up to 8 daisy chained dot matrix LEDs
 *
 * Origin Author:  Marcelo Moraes - Sorocaba/SP-Brazil - July 9th, 2013
 *  http://www.instructables.com/id/16x8-LED-dot-matrix-with-MAX7219-module/
 *  https://code.google.com/p/arudino-maxmatrix-library/        
 *
 * Modified by:    Olaf Meier
 *  Changed some characters and included sketch into my master design
 *
 * Hardware connection:  13  =  CLK
 *                       11  =  Din
 *                       9   =  CS  
 *                       Vcc =  5V * Hardware connection   
 *                       Gnd =  0V * Hardware connection
 */
/*********************************************************************/
/*********************************************************************/
/*
  Declaration of global constants and initialization of variables.
  Add includes.
 */
/*********************************************************************/
/***  Software release and date  ***/
const char* author                =  "Olaf Meier";
const char* revision              =  "R.0.1";
const char* date                  =  "2012/09/28";

#if ARDUINO < 100
#include <WProgram.h>    // Add other libraries on demand as requested
#else
#include <Arduino.h>     // Needed when working with libraries
#endif

/*********************************************************************/
/*
  Declare constants and variables for the optional serial monitor for
  debugging.
 */
int debug=0; // Debug counter; if set = 1, will write values via serial
const unsigned int baudRate = 9600; // Baud rate for the serial monitor

/*
  Declare constants and variables for the dot matrix display.
  Include Libraries
 */
#include <MaxMatrix.h>
//#include <avr/pgmspace.h>

/*
  Hardware connection. Dasiy chain DOUT with DIN of the next module
 */
int data     =  11;           // (13) DIN pin of MAX7219 module
int load     =  9;            // (10) CS pin of MAX7219 module
int clock    =  13;           // (9) CLK pin of MAX7219 module

/***  Number of used MAX7219 dot matrix modules  ***/
int maxInUse =  3;

/***  Initialize MAX7219 library  ***/
MaxMatrix m(data, load, clock, maxInUse);

byte buffer[100];

/***  Table according ASCII chart 32..127  ***/
/***  Initialize Sprite starting with number of rows from total.  ***/
PROGMEM const byte CH[] = {
3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ bkslh
2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
4, 8, B01111110, B01001000, B01001000, B00110000, B00000000, // b
4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
3, 8, B00001000, B01111100, B00001010, B00000000, B00000000, // f
4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

/***  Create the needed sentenses  ***/
char string110[]="Bla do Chico rolando mensagem em matriz de LEDs com o MAX7219       ";

/*********************************************************************/
void setup() {
  Serial.begin(baudRate);        // ...set up the serial output

  /***  Optional Debug routine via serial monitor  ***/
  if (debug) {  // To see some values for debugging in general...
    /***  Start class Serial with function/method begin(9600)  ***/
    /***  Instance variable .dot operator. method  ***/
    Serial.println("Debugging activated");
  }                                              // End of debug

  /***  Show software release  ***/
  Serial.println();
  Serial.print(author);
  Serial.print("\t");
  Serial.print(revision);                        
  Serial.print("\t");
  Serial.println(date); 
  Serial.println();

/*********************************************************************/
  m.init();                     // Initialize module
  m.setIntensity(2);            // Dot matix intensity 0-15

} // End of void setup()

/*********************************************************************/
void loop() {
/*
  Display the active sentence. printStringWithShift(string_, delay)
 */
  printStringWithShift(string110, 125);
} // End of void loop()


/*********************************************************************/
void printCharWithShift(char c, int shift_speed){
  if (c < 32) return;
  c -= 32;
  memcpy_P(buffer, CH + 7*c, 7);
  m.writeSprite(32, 0, buffer);
  m.setColumn(32 + buffer[0], 0);
  for (int i=0; i<buffer[0]+1; i++)
  {
    delay(shift_speed);
    m.shiftLeft(false, false);
  }
}


/*********************************************************************/
void printStringWithShift(char* s, int shift_speed){
  while (*s != 0){
    printCharWithShift(*s, shift_speed);
    s++;
  }
}

Código inserido e verificado, podemos conectar o Arduino à interface USB do computador e efetuar o upload do programa.

Após a carga e iniciação da execução do código teremos nosso letreiro operativo, como mostrado a seguir:

Para alterar a mensagem exibida basta editar o sketch, mais especificamente a linha:

char string110[]="...SUA MENSAGEM AQUI...";

Lembrando que o gerador de caracteres não dá suporte a caracteres acentuados e cedilha.

Daqui por diante o que pode ser dito é: BOA DIVERSÃO!