STM32F1与STM32CubeIDE编程实例-Max7219驱动4位LED点阵(基于SPI)

Max7219驱动4位LED点阵(基于SPI)

MAX7219/MAX7221是紧凑型串行输入/输出共阴极显示驱动器，可将微处理器(μPs)连接至多达8位的7段数字LED显示器、条形图显示器或64个独立LED。 片上包括 BCD 代码 B 解码器、多路扫描电路、段和数字驱动器以及存储每个数字的 8x8 静态 RAM。 只需要一个外部电阻来设置所有 LED 的段电流。 MAX7221 与 SPI™、QSPI™ 和 MICROWIRE™ 兼容，并具有限摆率的段驱动器以降低 EMI。

LED点阵是一个二维图案阵列，用于表示字符、符号和图像。Max7219与LED点阵的连接如下：

在前面的文章中，我们通过两种方式驱动Max7219，即SPI方式和GPIO方式，请参考：

• MAX7219驱动8位7段数码管(基于GPIO)
• MAX7219驱动8位7段数码管(基于SPI)

1、Max7219配置

开发环境搭建、系统时钟配置、调试配置及串口配置，请参考：

• STM32F1与STM32CubeIDE快速入门-开发环境搭建
• STM32F1与STM32CubeIDE快速入门-GPIO概述与点亮LED
• STM32F1与STM32CubeIDE快速入门-USART/UART串口通信

本次配置如下：

2、Max7219驱动LED点阵实现

1）驱动基本定义

/\*
 \* max7219\_matrix.h
 \*
 \* Created on: 2022年5月8日
 \* Author: jenson
 \*/

#ifndef \_\_MAX7219\_MATRIX\_H\_\_
#define \_\_MAX7219\_MATRIX\_H\_\_

#include <stdio.h>
#include <stm32f1xx\_hal.h>

#define MAX7219\_USE\_SPI 1
#define MAX7219\_BUFFER\_USE\_STATIC 1

#define MAX7219\_NOOP\_REGISTER 0x00
#define MAX7219\_DIGIT0\_REGISTER 0x01
#define MAX7219\_DIGIT1\_REGISTER 0x02
#define MAX7219\_DIGIT2\_REGISTER 0x03
#define MAX7219\_DIGIT3\_REGISTER 0x04
#define MAX7219\_DIGIT4\_REGISTER 0x05
#define MAX7219\_DIGIT5\_REGISTER 0x06
#define MAX7219\_DIGIT6\_REGISTER 0x07
#define MAX7219\_DIGIT7\_REGISTER 0x08

#define MAX7219\_DECODE\_MODE\_REGISTER 0x09
#define MAX7219\_INTENSITY\_REGISTER 0x0A
#define MAX7219\_SCAN\_LIMIT\_REGISTER 0x0B
#define MAX7219\_SHUTDOWN\_REGISTER 0x0C
#define MAX7219\_DISPLAY\_TEST\_REGISTER 0x0F

#define MAX7219\_INTENSITY\_MIN 0x00
#define MAX7219\_INTENSITY\_MAX 0x0F

#define MAX\_NUM\_MATRIXES 4
#define MAXTRIX\_ROW 8
#define MAXTRIX\_COL 8

typedef enum {
	MAX7219_SCAN_DIGIT_0 = 0,
	MAX7219_SCAN_DIGIT_0_1 = 1,
	MAX7219_SCAN_DIGIT_0_2 = 2,
	MAX7219_SCAN_DIGIT_0_3 = 3,
	MAX7219_SCAN_DIGIT_0_4 = 4,
	MAX7219_SCAN_DIGIT_0_5 = 5,
	MAX7219_SCAN_DIGIT_0_6 = 6,
	MAX7219_SCAN_DIGIT_0_7 = 7,
} max7219\_scan\_limit\_type\_t;

typedef enum {
	MAX7219_NoDecode = 0,
	MAX7219_DecodeFor0 = 1,
	MAX7219_DecodeFor3_0 = 2,
	MAX7219_DecodeFor7_0 = 3
} max7219\_decode\_mode\_t;

typedef enum {
	MAX7219_OK = 0,
	MAX7219_ERROR = 1,
	MAX7219_UNSUPPORTED_CHAR = 2,
	MAX7219_OUT_OF_RANGE = 3
} MAX7219_STATUS;

typedef struct {
	uint8\_t id;
#if MAX7219\_USE\_SPI
	SPI_HandleTypeDef \*SPIx;
	GPIO_TypeDef \*SPI_CS_GPIOx;
	uint16\_t SPI_CS_Pin;
# else
	GPIO_TypeDef \*MATRIX_CS_GPIOx;
	uint16\_t MATRIX_CS_Pin;
	GPIO_TypeDef \*MATRIX_CLK_GPIOx;
	uint16\_t MATRIX_CLK_Pin;
	GPIO_TypeDef \*MATRIX_DIN_GPIOx;
	uint16\_t MATRIX_DIN_Pin;
#endif
	uint8\_t rows;
	uint8\_t cols;
	uint16\_t buffer_len;
	uint8\_t brightness;
	uint8\_t digits;
	uint8\_t number_of_ic;
#if MAX7219\_BUFFER\_USE\_STATIC
	uint8\_t (\*buffer)[MAXTRIX_COL];
#else
	uint8\_t \*(\*buffer);
#endif
} max7219\_matrix\_t;

MAX7219_STATUS max7219\_matrix\_init(max7219\_matrix\_t \*dev);
MAX7219_STATUS max7219\_matrix\_set\_decode\_mode(max7219\_matrix\_t \*dev,
		uint8\_t index, max7219\_decode\_mode\_t mode);
void max7219\_matrix\_set\_brightness(max7219\_matrix\_t \*dev, uint8\_t index,
		uint8\_t level);

void max7219\_matrix\_clear\_all(max7219\_matrix\_t \*dev);
void max7219\_matrix\_clear\_at(max7219\_matrix\_t \*dev, uint8\_t index);
void max7219\_matrix\_turn\_on(max7219\_matrix\_t \*dev, uint8\_t index);
void max7219\_matrix\_turn\_off(max7219\_matrix\_t \*dev, uint8\_t index);

void max7219\_matrix\_test\_start(max7219\_matrix\_t \*dev, uint8\_t index);
void max7219\_matrix\_test\_stop(max7219\_matrix\_t \*dev, uint8\_t index);
void max7219\_matrix\_set\_scan\_limit(max7219\_matrix\_t \*dev, uint8\_t index,
		max7219\_scan\_limit\_type\_t type);
void max7219\_matrix\_set\_row\_data(max7219\_matrix\_t \*dev, uint8\_t index,
		uint8\_t \*data);
void max7219\_matrix\_set\_data(max7219\_matrix\_t \*dev, uint8\_t index,
		uint64\_t data);
//void max7219\_matrix\_set\_pixel(max7219\_matrix\_t \*dev,uint8\_t index,uint8\_t row,uint8\_t col,uint8\_t data);
void max7219\_matrix\_left\_shift(max7219\_matrix\_t \*dev, uint8\_t step);
void max7219\_matrix\_right\_shift(max7219\_matrix\_t \*dev, uint8\_t step);
void max7219\_matrix\_display(max7219\_matrix\_t \*dev);
//void max7219\_matrix\_display\_pixel(max7219\_matrix\_t \*dev);
uint64\_t max7219\_matrix\_decode\_char(uint8\_t ch);
uint64\_t max7219\_matrix\_decode\_number(uint8\_t number);

#endif /\* \_\_MAX7219\_MATRIX\_H\_\_ \*/

2）驱动定义实现

/\*
 \* max7219\_matrix.c
 \*
 \* Created on: 2022年5月8日
 \* Author: jenson
 \*/

#include "max7219\_matrix.h"
#include <string.h>
#include <stdlib.h>

#if (MAX7219\_USE\_SPI == 0)
#include "shift\_out.h"
#endif

#if MAX7219\_BUFFER\_USE\_STATIC
static volatile uint8\_t __s_buffer[MAX_NUM_MATRIXES][MAXTRIX_COL];
#endif

const uint64\_t symbol[] = { 0x1800183860663c00, 0x10387cfefeee4400,
		0x060e0c0808281800, 0x10307efe7e301000, 0x1018fcfefc181000 };

const uint64\_t numbers[] = {
/\* 8 => 1 row \*/
0x3c66666e76663c00, /\* 0 \*/
0x7e1818181c181800, /\* 1 \*/
0x7e060c3060663c00, /\* 2 \*/
0x3c66603860663c00, /\* 3 \*/
0x30307e3234383000, /\* 4 \*/
0x3c6660603e067e00, /\* 5 \*/
0x3c66663e06663c00, /\* 6 \*/
0x1818183030667e00, /\* 7 \*/
0x3c66663c66663c00, /\* 8 \*/
0x3c66607c66663c00, /\* 9 \*/
};

const uint64\_t Atoz[] = {  0x6666667e66663c00, /\* A \*/
0x3e66663e66663e00, /\* B \*/
0x3c66060606663c00, 0x3e66666666663e00, 0x7e06063e06067e00, 0x0606063e06067e00,
		0x3c66760606663c00, 0x6666667e66666600, 0x3c18181818183c00,
		0x1c36363030307800, 0x66361e0e1e366600, 0x7e06060606060600,
		0xc6c6c6d6feeec600, 0xc6c6e6f6decec600, 0x3c66666666663c00,
		0x06063e6666663e00, 0x603c766666663c00, 0x66361e3e66663e00,
		0x3c66603c06663c00, 0x18181818185a7e00, 0x7c66666666666600,
		0x183c666666666600, 0xc6eefed6c6c6c600, 0xc6c66c386cc6c600,
		0x1818183c66666600, 0x7e060c1830607e00, 0x0000000000000000,
		0x7c667c603c000000, 0x3e66663e06060600, 0x3c6606663c000000,
		0x7c66667c60606000, 0x3c067e663c000000, 0x0c0c3e0c0c6c3800,
		0x3c607c66667c0000, 0x6666663e06060600, 0x3c18181800180000,
		0x1c36363030003000, 0x66361e3666060600, 0x1818181818181800,
		0xd6d6feeec6000000, 0x6666667e3e000000, 0x3c6666663c000000,
		0x06063e66663e0000, 0xf0b03c36363c0000, 0x060666663e000000,
		0x3e403c027c000000, 0x1818187e18180000, 0x7c66666666000000,
		0x183c666600000000, 0x7cd6d6d6c6000000, 0x663c183c66000000,
		0x3c607c6666000000, /\* y \*/
		0x3c0c18303c000000 /\* z \*/
};

#if MAX7219\_USE\_SPI
void \_\_max7219\_matrix\_cs\_low(max7219\_matrix\_t \*dev);
void \_\_max7219\_matrix\_cs\_high(max7219\_matrix\_t \*dev);
void \_\_max7219\_matrix\_write(max7219\_matrix\_t \*dev, uint8\_t index,
		int8\_t reg_number, int8\_t data);
void \_\_max7219\_matrix\_write\_digit(max7219\_matrix\_t \*dev, uint8\_t index,
		uint8\_t digit, int8\_t value);

void \_\_max7219\_matrix\_cs\_low(max7219\_matrix\_t \*dev) {
	HAL\_GPIO\_WritePin(dev->SPI_CS_GPIOx, dev->SPI_CS_Pin, GPIO_PIN_RESET);
}

void \_\_max7219\_matrix\_cs\_high(max7219\_matrix\_t \*dev) {
	HAL\_GPIO\_WritePin(dev->SPI_CS_GPIOx, dev->SPI_CS_Pin, GPIO_PIN_SET);
}

#else

void \_\_max7219\_matrix\_cs\_low(max7219\_matrix\_t \*dev);
void \_\_max7219\_matrix\_cs\_high(max7219\_matrix\_t \*dev);

void \_\_max7219\_matrix\_cs\_low(max7219\_matrix\_t \*dev) {
	HAL\_GPIO\_WritePin(dev->MATRIX_CS_GPIOx, dev->MATRIX_CS_Pin, GPIO_PIN_RESET);
}

void \_\_max7219\_matrix\_cs\_high(max7219\_matrix\_t \*dev) {
	HAL\_GPIO\_WritePin(dev->MATRIX_CS_GPIOx, dev->MATRIX_CS_Pin, GPIO_PIN_SET);
}

#endif

void \_\_max7219\_matrix\_write(max7219\_matrix\_t \*dev, uint8\_t index,
		int8\_t reg_number, int8\_t data) {

	if (index >= dev->digits) {
		return;
	}
	uint8\_t message[2] = { MAX7219_NOOP_REGISTER, MAX7219_NOOP_REGISTER };

	\_\_max7219\_matrix\_cs\_low(dev);

	// index之后所有max7219进行noop操作
	for (uint8\_t i = index; i < dev->digits - 1; i++) {
#if MAX7219\_USE\_SPI
		HAL\_SPI\_Transmit(dev->SPIx, (uint8\_t\*) message, 2, 100);
#else
		shift\_out(dev->MATRIX_DIN_GPIOx, dev->MATRIX_DIN_Pin,
				dev->MATRIX_CLK_GPIOx, dev->MATRIX_CLK_Pin, MSBFIRST,
				message[0]);
		shift\_out(dev->MATRIX_DIN_GPIOx, dev->MATRIX_DIN_Pin,
				dev->MATRIX_CLK_GPIOx, dev->MATRIX_CLK_Pin, MSBFIRST,
				message[1]);
#endif
	}
	// 向第index位置max7219写寄存器和数据

	message[0] = reg_number;
	message[1] = data;
#if MAX7219\_USE\_SPI
	HAL\_SPI\_Transmit(dev->SPIx, (uint8\_t\*) message, 2, 100);
#else
	shift\_out(dev->MATRIX_DIN_GPIOx, dev->MATRIX_DIN_Pin, dev->MATRIX_CLK_GPIOx,
			dev->MATRIX_CLK_Pin, MSBFIRST, message[0]);
	shift\_out(dev->MATRIX_DIN_GPIOx, dev->MATRIX_DIN_Pin, dev->MATRIX_CLK_GPIOx,
			dev->MATRIX_CLK_Pin, MSBFIRST, message[1]);
#endif
	// index之前所有max7219进行noop操作
	message[0] = MAX7219_NOOP_REGISTER;
	message[1] = MAX7219_NOOP_REGISTER;

	for (uint8\_t i = 0; i < index; i++) {
#if MAX7219\_USE\_SPI
		HAL\_SPI\_Transmit(dev->SPIx, (uint8\_t\*) message, 2, 100);
#else
		shift\_out(dev->MATRIX_DIN_GPIOx, dev->MATRIX_DIN_Pin,
				dev->MATRIX_CLK_GPIOx, dev->MATRIX_CLK_Pin, MSBFIRST,
				message[0]);
		shift\_out(dev->MATRIX_DIN_GPIOx, dev->MATRIX_DIN_Pin,
				dev->MATRIX_CLK_GPIOx, dev->MATRIX_CLK_Pin, MSBFIRST,
				message[1]);
#endif
	}

	\_\_max7219\_matrix\_cs\_high(dev);

}

void \_\_max7219\_matrix\_write\_digit(max7219\_matrix\_t \*dev, uint8\_t index,
		uint8\_t digit, int8\_t value) {
	if (index >= dev->digits) {
		return;
	}

	\_\_max7219\_matrix\_write(dev, index, digit + 1, value);
}

MAX7219_STATUS max7219\_matrix\_init(max7219\_matrix\_t \*dev) {
	if (dev->number_of_ic > MAX_NUM_MATRIXES) {
		return MAX7219_ERROR;
	}
#if MAX7219\_BUFFER\_USE\_STATIC
	dev->buffer = __s_buffer;
#else
	dev->buffer = NULL;
	dev->buffer = malloc(sizeof(uint32\_t) \* dev->number_of_ic);
	if (dev->buffer == NULL) {
		return MAX7219_ERROR;
	}

	for (int i = 0; i < dev->number_of_ic; i++) {
		dev->buffer[i] = NULL;
		dev->buffer[i] = malloc(sizeof(uint8\_t) \* dev->rows);
		if (dev->buffer[i] == NULL) {
			return MAX7219_ERROR;
		}
	}
#endif
	dev->digits = dev->number_of_ic;
	for (uint8\_t i = 0; i < dev->digits; i++) {

		max7219\_matrix\_turn\_on(dev, i);
		max7219\_matrix\_set\_brightness(dev, i, dev->brightness);
		max7219\_matrix\_set\_decode\_mode(dev, i, MAX7219_NoDecode);
		max7219\_matrix\_set\_scan\_limit(dev, i, MAX7219_SCAN_DIGIT_0_7);
		max7219\_matrix\_test\_stop(dev, i);
		max7219\_matrix\_clear\_at(dev, i);
	}
	max7219\_matrix\_display(dev);
	return MAX7219_OK;
}

MAX7219_STATUS max7219\_matrix\_set\_decode\_mode(max7219\_matrix\_t \*dev,
		uint8\_t index, max7219\_decode\_mode\_t mode) {
	if (mode > 4) {
		return MAX7219_ERROR;
	}
	\_\_max7219\_matrix\_write(dev, index, MAX7219_DECODE_MODE_REGISTER, mode);
	return MAX7219_OK;
}

void max7219\_matrix\_set\_brightness(max7219\_matrix\_t \*dev, uint8\_t index,
		uint8\_t level) {
	dev->brightness = level & 0x0F;
	\_\_max7219\_matrix\_write(dev, index, MAX7219_INTENSITY_REGISTER,
			dev->brightness);
}

void max7219\_matrix\_clear\_all(max7219\_matrix\_t \*dev) {
	for (uint8\_t i = 0; i < dev->digits; i++) {
		max7219\_matrix\_clear\_at(dev, i);
	}
}

void max7219\_matrix\_clear\_at(max7219\_matrix\_t \*dev, uint8\_t index) {
	for (uint8\_t i = 0; i < 8; i++) {
		dev->buffer[index][i] = 0x00;
	}
}

void max7219\_matrix\_turn\_on(max7219\_matrix\_t \*dev, uint8\_t index) {
	\_\_max7219\_matrix\_write(dev, index, MAX7219_SHUTDOWN_REGISTER, 0x01);
}
void max7219\_matrix\_turn\_off(max7219\_matrix\_t \*dev, uint8\_t index) {
	\_\_max7219\_matrix\_write(dev, index, MAX7219_SHUTDOWN_REGISTER, 0x00);
}

void max7219\_matrix\_test\_start(max7219\_matrix\_t \*dev, uint8\_t index) {
	\_\_max7219\_matrix\_write(dev, index, MAX7219_DISPLAY_TEST_REGISTER, 0x01);
}
void max7219\_matrix\_test\_stop(max7219\_matrix\_t \*dev, uint8\_t index) {
	\_\_max7219\_matrix\_write(dev, index, MAX7219_DISPLAY_TEST_REGISTER, 0x00);
}

void max7219\_matrix\_set\_scan\_limit(max7219\_matrix\_t \*dev, uint8\_t index,
		max7219\_scan\_limit\_type\_t type) {
	\_\_max7219\_matrix\_write(dev, index, MAX7219_SCAN_LIMIT_REGISTER, type);

}

void max7219\_matrix\_set\_row\_data(max7219\_matrix\_t \*dev, uint8\_t index,
		uint8\_t \*data) {
	uint8\_t len = strlen(data);
	if (len > dev->rows || len < dev->rows) {
		return;
	}
	if (index >= dev->digits) {
		return;
	}
	for (uint8\_t i = 0; i < dev->rows; i++) {
		dev->buffer[index][i] = data[i];
	}
}

void max7219\_matrix\_set\_data(max7219\_matrix\_t \*dev, uint8\_t index,
		uint64\_t datas) {
	if (index >= dev->digits) {
		return;
	}
	uint64\_t temp = datas;
	for (uint8\_t i = 0; i < dev->rows; i++) {
		uint8\_t data = temp & 0xFF;
		dev->buffer[index][7 - i] = data;
		temp = temp >> 8;
	}
}

void max7219\_matrix\_set\_pixel(max7219\_matrix\_t \*dev, uint8\_t index,
		uint8\_t digit, uint8\_t data) {
	if (index >= dev->digits) {
		return;
	}
	if (digit > dev->cols) {
		return;
	}

	dev->buffer[index][digit] = data;
}

void max7219\_matrix\_left\_shift(max7219\_matrix\_t \*dev, uint8\_t step) {
	uint8\_t lsb_data0, lsb_data1, lsb_data2, lsb_data3;
	for (uint8\_t i = 0; i < dev->cols; i++) {
		lsb_data3 = ((dev->buffer[3][i] & 0x01) << 7);
		dev->buffer[3][i] = dev->buffer[3][i] >> 1;

		lsb_data2 = ((dev->buffer[2][i] & 0x01) << 7);
		dev->buffer[2][i] = dev->buffer[2][i] >> 1;
		dev->buffer[2][i] |= lsb_data3;

		lsb_data1 = ((dev->buffer[1][i] & 0x01) << 7);
		dev->buffer[1][i] = dev->buffer[1][i] >> 1;
		dev->buffer[1][i] |= lsb_data2;

		lsb_data0 = ((dev->buffer[0][i] & 0x01) << 7);
		dev->buffer[0][i] = dev->buffer[0][i] >> 1;
		dev->buffer[0][i] |= lsb_data1;
		dev->buffer[3][i] |= lsb_data0;

	}
}

void max7219\_matrix\_right\_shift(max7219\_matrix\_t \*dev, uint8\_t step) {
	uint8\_t lsb_data0, lsb_data1, lsb_data2, lsb_data3;
	for (int i = 0; i < 8; i++) {
		lsb_data0 = ((dev->buffer[0][i] & 0x80) >> 7);
		dev->buffer[0][i] = dev->buffer[0][i] << 1;

		lsb_data1 = ((dev->buffer[1][i] & 0x80) >> 7);
		dev->buffer[1][i] = dev->buffer[1][i] << 1;
		dev->buffer[1][i] |= lsb_data0;

		lsb_data2 = ((dev->buffer[2][i] & 0x80) >> 7);
		dev->buffer[2][i] = dev->buffer[2][i] << 1;
		dev->buffer[2][i] |= lsb_data1;

		lsb_data3 = ((dev->buffer[3][i] & 0x80) >> 7);
		dev->buffer[3][i] = dev->buffer[3][i] << 1;
		dev->buffer[3][i] |= lsb_data2;
		dev->buffer[0][i] |= lsb_data3;
	}
}

void max7219\_matrix\_display(max7219\_matrix\_t \*dev) {
	for (uint8\_t index = 0; index < dev->digits; index++) {
		for (uint8\_t digit = 0; digit < 8; digit++) {
			uint8\_t data = dev->buffer[index][digit];
			\_\_max7219\_matrix\_write\_digit(dev, index, digit, data);
		}
	}
}

uint64\_t max7219\_matrix\_decode\_char(uint8\_t ch) {
	return Atoz[ch - 65];
}

uint64\_t max7219\_matrix\_decode\_number(uint8\_t number) {
	if (number < 0 || number > 9) {
		return 0xFFFF;
	}
	return numbers[number];
}

3、驱动测试

在main.c文件中添加如下代码：

/\* Private includes ----------------------------------------------------------\*/
/\* USER CODE BEGIN Includes \*/
#include <string.h>
#include "max7219\_matrix/max7219\_matrix.h"

/\* USER CODE END Includes \*/

/\* USER CODE BEGIN PV \*/
max7219\_matrix\_t dev;
/\* USER CODE END PV \*/

int main(void) {
	/\* USER CODE BEGIN 1 \*/

	/\* USER CODE END 1 \*/

	/\* MCU Configuration--------------------------------------------------------\*/

	/\* Reset of all peripherals, Initializes the Flash interface and the Systick. \*/
	HAL\_Init();

	/\* USER CODE BEGIN Init \*/

	/\* USER CODE END Init \*/

	/\* Configure the system clock \*/
	SystemClock\_Config();

	/\* USER CODE BEGIN SysInit \*/

	/\* USER CODE END SysInit \*/

	/\* Initialize all configured peripherals \*/
	MX\_GPIO\_Init();
	MX\_USART1\_UART\_Init();
	MX\_SPI1\_Init();

	dev.rows = 8;
	dev.cols = 8;
	dev.brightness = 3;
	dev.id = 1;
	dev.number_of_ic = 4;
#if MAX7219\_USE\_SPI
	dev.SPIx = &hspi1;
	dev.SPI_CS_GPIOx = MAX7219_CS_GPIO_Port;
	dev.SPI_CS_Pin = MAX7219_CS_Pin;
#else
	dev.MATRIX_CLK_GPIOx = CLK_GPIO_Port;
	dev.MATRIX_CLK_Pin = CLK_Pin;
	dev.MATRIX_CS_GPIOx = CS_GPIO_Port;
	dev.MATRIX_CS_Pin = CS_Pin;
	dev.MATRIX_DIN_GPIOx = DIN_GPIO_Port;
	dev.MATRIX_DIN_Pin = DIN_Pin;
#endif
	max7219\_matrix\_init(&dev);

	/\* USER CODE END 2 \*/

	/\* Infinite loop \*/
	/\* USER CODE BEGIN WHILE \*/
	while (1) {
		/\* USER CODE END WHILE \*/

		/\* USER CODE BEGIN 3 \*/
        
		max7219\_matrix\_set\_data(&dev, 0, max7219\_matrix\_decode\_char('B'));
		max7219\_matrix\_set\_data(&dev, 1, max7219\_matrix\_decode\_char('A'));
		max7219\_matrix\_set\_data(&dev, 2, max7219\_matrix\_decode\_char('N'));
		max7219\_matrix\_set\_data(&dev, 3, max7219\_matrix\_decode\_char('G'));
		max7219\_matrix\_display(&dev);
		HAL\_Delay(1000);

		for (int i = 0; i < 24; i++) {
			max7219\_matrix\_left\_shift(&dev, 1);
			max7219\_matrix\_display(&dev);
			HAL\_Delay(100);
		}
		HAL\_Delay(1000);
		for (int i = 0; i < 24; i++) {
			max7219\_matrix\_right\_shift(&dev, 1);
			max7219\_matrix\_display(&dev);
			HAL\_Delay(100);
		}
		HAL\_Delay(1000);
	}
	/\* USER CODE END 3 \*/
}

文章来源: https://iotsmart.blog.csdn.net/article/details/125684904