MAX7219 LED Dot Matrix Display com Raspberry Pi Pico

Tempo de leitura: 11 minutes

Neste tutorial, aprenderemos a fazer a interface do display de matriz de pontos LED MAX7219 com o Raspberry Pi Pico. Em primeiro lugar, examinaremos a introdução, pinagem do módulo de exibição de matriz de pontos LED MAX7219. É uma matriz de LED usada para exibir vários tipos de textos, símbolos e imagens na forma de pontos que consiste em LEDs. Através deste tutorial, vamos familiarizá-lo com o display matricial MAX7219 e programar Raspberry Pi Pico para mostrar várias demonstrações de exibição de textos. Isso incluirá a exibição e rolagem de texto na matriz de pontos.

MAX7219 Display de matriz de pontos LED

O display matricial LED MAX7219 é um dos populares disponíveis no mercado e usado por estudantes, amadores de eletrônica e especialmente em aplicações de display industrial. Existem dois tipos de módulos geralmente disponíveis. Estes são o módulo FC-16 e o módulo genérico.

Cada módulo é composto por duas unidades. Uma é a matriz de pontos LED 8X8 e a outra é o IC MAX7219.

Matriz de pontos de LED

As matrizes de pontos LED estão disponíveis em várias dimensões (7×5,8×8, 7×15, etc). A matriz típica de 8 × 8 LEDs é mostrada abaixo, composta por 64 LEDs, 8 para cada linha e coluna. Cada LED é endereçado por seu número de linha e coluna. Cada LED é referido como um ponto.

Para fazer uma matriz de pontos 8×8, todos os terminais dos anodos são conectados juntos nas linhas R1 a R8, da mesma forma, os cátodos são conectados nas colunas C1 a C8. A razão para conectar todas as linhas e colunas é salvar o número necessário de pinos para controlar cada ponto de LED. Ao fazer isso, o número necessário de pinos de E/S foi reduzido para 16. Caso contrário, precisaremos de 64 pinos para controlar uma matriz de LEDs 8×8. Este método de controlar um grande número de LEDs com poucos pinos é conhecido como multiplexação.

Para ligar um do específico, precisamos aplicar uma tensão positiva na respectiva linha desse ponto e negativa ou terra na respectiva coluna desse ponto. Se a linha obtiver tensão positiva e a coluna ficar negativa, apenas um LED específico acenderá.

Por exemplo, se você deseja acender um LED conectado entre R2 e C1, temos que aplicar a lógica 00000010 na linha R2 e 11111110 na coluna C1. Se R5 for puxado para cima e C4 for puxado para baixo, então o LED na quinta linha e na quarta coluna estaria alto. Lógica semelhante também pode ser aplicada a outras linhas e colunas para ligar e desligar cada LED de linha e coluna. Além disso, para exibir o texto na matriz de pontos, controlamos cada LED a uma velocidade muito rápida que o olho humano sente como se os LEDs estivessem constantemente ligados.

 

MAX7219 IC

MAX7219 é um driver de exibição de cátodo comum IC com entradas seriais e pinos de saída. Tem uma capacidade de corrente ajustável que pode ser ajustada usando apenas um resistor externo. Além disso, possui uma interface serial de quatro fios que pode ser facilmente conectada a todos os microprocessadores. Ele pode acionar 64 LEDs individuais conectados em seus pinos de saída usando apenas 4 fios usando a placa Raspberry Pi Pico. Além disso, ele pode conduzir exibições de matriz de pontos, exibições de 7 segmentos e gráficos de barras.

Além disso, o MAX7219 possui um decodificador BCD integrado que facilita o uso com visores numéricos de sete segmentos. Além disso, possui uma RAM estática de 8×8 que podemos usar para armazenar números. É um dos drivers de exibição mais populares IC.

Alguns dos principais recursos do MAX7219 incluem:

  1. É um LED driver display IC com interface serial de 10MHz que permite ao usuário selecionar o dígito de decodificação/sem decodificação.
  2. Seu funcionamento é especificado em uma faixa de tensão de +4,0 a +5,5V. Normalmente, a alimentação de tensão de +5V é usada.
  3. Ele fornece um recurso de controle de intensidade de brilho digital e analógico e um modo de desligamento de 150µA no qual a corrente de todos os segmentos é puxada para o terra.
  4. Consome energia muito baixa.
  5. Os dados são exibidos em segmentos com um tempo de atraso de 2,2 ms.
  6. O MAX7219 funciona bem em uma faixa de temperatura de 0°C a +70°C.
  7. A corrente máxima para cada pino de segmento é 100mA e para cada pino terra DIGIT é 500mA

 

Pinagem do módulo matricial MAX7219

O módulo MAX7219 possui 5 terminais que consistem em terminais SPI e fonte de alimentação. Ambos os tipos de módulos têm as mesmas conexões nos dois lados. De um lado estão as conexões de entrada e do outro as conexões de saída Abaixo você pode ver a pinagem do módulo genérico.

Conexões de entrada

As conexões de entrada da matriz de LED são conectadas com Raspberry Pi Pico

  • VCC: Este pino fornece energia ao módulo MAX7219. Está conectado com o pino de 5V do Raspberry Pi Pico.
  • GND: Este é o pino terra que deve ser conectado com o pino terra do Raspberry Pi Pico.
  • DIN: Estes são os dados no pino. Ele é usado como a entrada SPI para o módulo.
  • CS: Este é o pino Chip Select para comunicação SPI.
  • CLK: Isso é chamado de pino ‘Serial Clock’ que é usado na saída do relógio serial SPI.

 

Conexões de Saída

As conexões de saída da matriz de LEDs são conectadas com o próximo módulo se houver necessidade de conectar mais unidades.

  • VCC: Está conectado ao VCC (5V) no próximo módulo
  • GND: Está conectado ao GND no próximo módulo
  • DOUT: Este é o pino de saída de dados. Ele é conectado ao pino DIN do próximo módulo.
  • CS: Este é conectado ao pino CS do próximo módulo
  • CLK: Este é conectado ao pino CLK do próximo módulo

 

Módulo de matriz de pontos LED MAX7219 Interface com Raspberry Pi Pico

Os seguintes componentes são necessários:

  • Raspberry PI Pico
  • Módulo MAX7219
  • Fios de conexão

Para este projeto, usaremos o módulo FC-16 composto por quatro unidades.

Agora, mostraremos como conectar o módulo MAX7219 e o Raspberry Pi Pico juntos.

A comunicação SPI ajuda a comunicar com o módulo MAX7219, que é comum em todos os microcontroladores. Assim, utilizaremos a interface SPI do Raspberry Pi Pico. Vamos primeiro aprender sobre a interface Raspberry Pi Pico SPI.

 

Pinos SPI Raspberry Pi Pico

Raspberry Pi Pico suporta dois periféricos SPI. Ambos os pinos do módulo SPI são acessíveis através dos pinos GPIO do Raspberry Pi Pico. A tabela a seguir mostra a conexão dos pinos GPIO com ambos os módulos SPI. Cada conexão dos pinos do controlador SPI pode ser configurada através de vários pinos GPIO conforme mostrado na figura. Mas antes de usar o SPI, você deve configurar no software quais pinos do GPIO você deseja usar com um periférico SP específico.

Controlador SPI Pinos GPIO
SPI0_RX GP0/GP4/GP16
SPI0_TX GP3/GP7/GP19
SPI0_SCK GP2/GP6/GP18
SPI0_CSn GP1/GP5/GP17
SPI1_RX GP8/GP12
SPI1_TX GP11/GP15
SPI1_SCK GP10/GP14
SPI1_CSn GP9/GP13

A figura abaixo mostra os pinos SPI do Raspberry Pi Pico.

A tabela abaixo mostra as conexões entre os dispositivos que utilizaremos em nosso projeto.

 

Raspberry Pi Pico com módulo de exibição de matriz de pontos LED MAX7219

Agora vamos ver como conectar o módulo MAX7219 e a placa Raspberry Pi Pico. A tabela abaixo mostra as conexões entre os dois dispositivos:

Modulo MAX7219 Raspberry Pi Pico
VCC VBUS (5V)
GND GND
DIN GP3 (SPI0_TX)
CS GP5 (SPI0_CSn)
CLK GP2 (SPI0_SCK)

Conforme mostrado na tabela, vamos conectar o terminal VCC do módulo MAX7219 com o pino 5V do Raspberry Pi Pico. Ambos os motivos serão comuns. Os pinos SPI GPIO do Raspberry Pi Pico estão sendo usados para conectar com cada um dos terminais SPI restantes do módulo MAX7219. Você também pode usar outros pinos Raspberry Pi Pico SPI.

Diagrama de conexão Raspberry Pi Pico com MAX7219 LED Dot Matrix
Diagrama de conexão Raspberry Pi Pico com MAX7219 LED Dot Matrix

 

 

Instalando a biblioteca MAX7219 MicroPython

Usaremos o Thonny IDE para programar nosso Raspberry Pi Pico. Certifique-se de ter a versão mais recente do IDE instalada em seu sistema. Para este projeto, precisaremos da biblioteca MicroPython max7219. Copie esta biblioteca e salve-a em seu Raspberry Pi Pico com o respectivo nome de arquivo (max7219.py) do link do GitHub.

Abra um novo arquivo no Thonny. Copie a biblioteca fornecida abaixo ou do link fornecido acima. Salve-o no Raspberry Pi Pico com o nome max7219.py na pasta lib.

max7219.py

"""
MicroPython max7219 cascadable 8x8 LED matrix driver
https://github.com/mcauser/micropython-max7219
MIT License
Copyright (c) 2017 Mike Causer
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""

from micropython import const
import framebuf

_NOOP = const(0)
_DIGIT0 = const(1)
_DECODEMODE = const(9)
_INTENSITY = const(10)
_SCANLIMIT = const(11)
_SHUTDOWN = const(12)
_DISPLAYTEST = const(15)

class Matrix8x8:
    def __init__(self, spi, cs, num):
        """
        Driver for cascading MAX7219 8x8 LED matrices.
        >>> import max7219
        >>> from machine import Pin, SPI
        >>> spi = SPI(1)
        >>> display = max7219.Matrix8x8(spi, Pin('X5'), 4)
        >>> display.text('1234',0,0,1)
        >>> display.show()
        """
        self.spi = spi
        self.cs = cs
        self.cs.init(cs.OUT, True)
        self.buffer = bytearray(8 * num)
        self.num = num
        fb = framebuf.FrameBuffer(self.buffer, 8 * num, 8, framebuf.MONO_HLSB)
        self.framebuf = fb
        # Provide methods for accessing FrameBuffer graphics primitives. This is a workround
        # because inheritance from a native class is currently unsupported.
        # http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
        self.fill = fb.fill  # (col)
        self.pixel = fb.pixel # (x, y[, c])
        self.hline = fb.hline  # (x, y, w, col)
        self.vline = fb.vline  # (x, y, h, col)
        self.line = fb.line  # (x1, y1, x2, y2, col)
        self.rect = fb.rect  # (x, y, w, h, col)
        self.fill_rect = fb.fill_rect  # (x, y, w, h, col)
        self.text = fb.text  # (string, x, y, col=1)
        self.scroll = fb.scroll  # (dx, dy)
        self.blit = fb.blit  # (fbuf, x, y[, key])
        self.init()

    def _write(self, command, data):
        self.cs(0)
        for m in range(self.num):
            self.spi.write(bytearray([command, data]))
        self.cs(1)

    def init(self):
        for command, data in (
            (_SHUTDOWN, 0),
            (_DISPLAYTEST, 0),
            (_SCANLIMIT, 7),
            (_DECODEMODE, 0),
            (_SHUTDOWN, 1),
        ):
            self._write(command, data)

    def brightness(self, value):
        if not 0 <= value <= 15:
            raise ValueError("Brightness out of range")
        self._write(_INTENSITY, value)

    def show(self):
        for y in range(8):
            self.cs(0)
            for m in range(self.num):
                self.spi.write(bytearray([_DIGIT0 + y, self.buffer[(y * self.num) + m]]))
            self.cs(1)

Raspberry Pi Pico com MAX7219 LED Matrix: MicroPython Sketches

Nesta seção, mostraremos como usar a matriz de LED MAX7219 com dois esboços. Poderemos imprimir vários textos na matriz LED. Além disso, também rolaremos um texto simples da direita para a esquerda.

MAX7219 Dot Matrix exibindo textos

Abra seu Thonny IDE e vá para Arquivo > Novo. Copie o código abaixo nesse arquivo. Este sketch exibirá três textos diferentes na matriz de LED após um atraso de 1 segundo.

from machine import Pin, SPI
import max7219
from time import sleep

spi = SPI(0,sck=Pin(2),mosi=Pin(3))
cs = Pin(5, Pin.OUT)

display = max7219.Matrix8x8(spi, cs, 4)

display.brightness(10)

while True:

    display.fill(0)
    display.text('PICO',0,0,1)
    display.show()
    sleep(1)

    display.fill(0)
    display.text('1234',0,0,1)
    display.show()
    sleep(1)

    display.fill(0)
    display.text('done',0,0,1)
    display.show()
    sleep(1)

Como o Código Funciona?

Nesta parte vamos discutir como o código funciona.

Importando Bibliotecas

Importaremos a biblioteca para a classe Pin e a classe SPI do módulo da máquina. Para interagir com os GPIOs de entrada/saída importaremos o módulo da máquina que contém as classes para interagir com os GPIOs. Também devemos importar o módulo sleep para inserir delay em nosso script MicroPython. Além disso, também importaremos a biblioteca max7219 para trabalhar com o display de LED.

from machine import Pin, SPI
import max7219
from time import sleep

Inicializando SPI

A próxima etapa é inicializar a interface SPI com os parâmetros necessários, incluindo o número do canal SPI e os pinos SPI, criando um objeto ‘spi’. Usando SPI(), especificamos o número do canal SPI como o primeiro parâmetro e os pinos SPI sck e mosi como o restante dos parâmetros.

spi = SPI(0,sck=Pin(2),mosi=Pin(3))

A seguir vamos configurar o pino GPIO conectado ao pino CS do módulo como pino de saída. O primeiro argumento na classe Pin() é o número do pino no qual estamos configurando a saída. A saída está no GP5 que está conectado ao CS. O segundo argumento mostra o modo pin, por exemplo. entrada digital ou modo de saída digital. Como estamos configurando o GP5 como saída digital, demos a ele como ‘Pin.Out’. Isso é armazenado no objeto ‘cs’

cs = Pin(5, Pin.OUT)

Em seguida, criaremos o objeto ‘display’ da matriz e especificaremos 4 dispositivos.

display = max7219.Matrix8x8(spi, cs, 4)

Vamos definir o brilho da tela usando o método brightness() no objeto de tela. Isso leva em um parâmetro de 1-15 onde 15 é o nível mais alto de brilho.

display.brightness(10)

Texto de exibição

Iremos alterar continuamente o texto a cada 1 segundo. Primeiro vamos exibir “PICO” depois os números “1234” e depois “done”.

while True:

    display.fill(0)
    display.text('PICO',0,0,1)
    display.show()
    sleep(1)

    display.fill(0)
    display.text('1234',0,0,1)
    display.show()
    sleep(1)

    display.fill(0)
    display.text('done',0,0,1)
    display.show()
    sleep(1)

Usando o método fill() no objeto de exibição e passando 0 como parâmetro dentro dele, primeiro limparemos a exibição.

Primeiro vamos exibir o texto ‘PICO’ por 1 segundo. Isso será feito usando text() e passando a string como primeiro parâmetro, x como segundo parâmetro, y como terceiro parâmetro e col=1 como último parâmetro. O método show() exibirá a string no display de LED.

display.fill(0)
     display.text('PICO',0,0,1)
     display.show()
     dormir(1)

Da mesma forma, exibiremos os números ‘1234’ e o texto ‘done’ depois disso.

display.fill(0)
display.text('1234',0,0,1)
display.show()
sleep(1)

display.fill(0)
display.text('done',0,0,1)
display.show()
sleep(1)

MAX7219 Dot Matrix MicroPython Sketch: Rolagem de texto

Abra seu Thonny IDE e vá para Arquivo > Novo. Copie o código abaixo nesse arquivo. Este sketch rolará um texto da direita para a esquerda em uma velocidade definida.

from machine import Pin, SPI
import max7219
from time import sleep

spi = SPI(0,sck=Pin(2),mosi=Pin(3))
cs = Pin(5, Pin.OUT)

display = max7219.Matrix8x8(spi,cs,4)

display.brightness(10)

scrolling_message = "SCROLLING"
length = len(scrolling_message)
column = (length * 8)

display.fill(0)
display.show()
sleep(1)

while True:
    for x in range(32, -column, -1):     
        display.fill(0)
        display.text(scrolling_message ,x,0,1)
        display.show()
        sleep(0.1)

Como funciona o código?

Discutiremos as partes em que estamos incorporando o recurso de rolagem. O restante do código é semelhante ao que discutimos acima.

Após inicializar a interface SPI, definir seu brilho e limpar o display, criaremos uma variável para conter o texto que desejamos rolar. No nosso caso, é ‘SCROLLING’. Isso é salvo na variável ‘scrolling_message.’

scrolling_message = "SCROLLING"

Em seguida, encontre o comprimento do texto.

length = len(scrolling_message)

Além disso, calcule as colunas para o texto de rolagem. Isso é encontrado multiplicando o comprimento do texto por 8.

column = (length * 8)

Dentro do loop while infinito, usaremos uma instrução for para rolar o texto. Primeiro, limpamos a tela de LED. Em seguida, usamos o método text() no objeto de exibição e escrevemos o texto de rolagem no buffer de quadros. Em seguida, exibimos o texto usando o método show() no objeto de exibição. Para definir a velocidade do texto de rolagem, adicionamos um atraso de 100 milissegundos usando o método sleep().

while True:
    for x in range(32, -column, -1):     
        display.fill(0)
        display.text(scrolling_message ,x,0,1)
        display.show()
        sleep(0.1)

 

Conclusão

Em conclusão, aprendemos a interface do módulo de exibição de matriz de LED MAX7219 dot com Raspberry Pi Pico. Analisamos dois esboços do MicroPython. Esses esboços nos familiarizaram com a exibição de texto simples na tela e também a rolagem em uma velocidade definida.

 

Visits: 2 Visits: 1126024