Raspberry Pi Pico: matriz led 8×32 com driver MAX7219 – Deslocamento de texto

Tempo de leitura: 8 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.

Neste iremos apresentar como fazer a matrix rolar o texto.

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á um texto rolando.

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

class matrix():
    def __init__(self):
        self.MAX7219_NUM = 4
        self.MAX7219_INVERT = False
        self.MAX7219_SCROLL_DELAY = 0.1
        cs_pin = 5

        spi = SPI(0)
        self.display = max7219.Matrix8x8(spi=spi, cs=Pin(cs_pin), num=self.MAX7219_NUM)
        self.display.brightness(2)
    
    def text_scroll(self, text, scroll_delay=None):
        if scroll_delay != None:
            self.MAX7219_SCROLL_DELAY = scroll_delay
        
        p = self.MAX7219_NUM * 8
        for p in range(self.MAX7219_NUM * 8, len(text) * -8 - 1, -1):
            self.display.fill(self.MAX7219_INVERT)
            self.display.text(text, p, 1, not self.MAX7219_INVERT)
            self.display.show()
            sleep(self.MAX7219_SCROLL_DELAY)

led = matrix()

while True:
    text = "CapSistema - Raspberry PI Pico + Matrix 8x32"
    led.text_scroll(text)

 

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.

import max7219
from machine import Pin, SPI
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.

self.display = max7219.Matrix8x8(spi=spi, cs=Pin(cs_pin), num=self.MAX7219_NUM)

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. Em seguida, criaremos o objeto ‘display’ da matriz e especificaremos 4 dispositivos.

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(2)

Texto de exibição

Iremos alterar continuamente o texto a cada 1 segundo. Vamos exibir “CapSistema – Raspberry PI Pico + Matrix 8×32”.

while True:
    text = "CapSistema - Raspberry PI Pico + Matrix 8x32"
    led.text_scroll(text)

Primeiro vamos exibir o texto ‘CapSistema – Raspberry PI Pico + Matrix 8×32’ por 1 segundo. Isso será feito usando a função text_scroll().

Fotos serão acrescentadas ao artigo em breve.

 

 

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