在本篇文章中，我们将学习如何使用MAX7219驱动器和Arduino开发板控制8×8 LED点阵显示屏。我们将举三个例子，第一个例子主要解释MAX7219的基本工作原理，在第二个例子中将看到8×8 LED点阵上的滚动文本是如何实现的，在第三个例子中通过蓝牙和自制Android应用程序来控制它们。

MAX7219

现在让我们仔细看看MAX7219驱动器。该IC能够驱动64个独立的LED，同时仅使用3根线与Arduino进行通信，而且我们还可以菊花链连接多个驱动器和点阵，并且仍使用相同的3线。

64个LED由IC的16个输出引脚驱动。现在的问题是如何做到这一点。那么同时点亮的最大LED数量实际为8。 LED排列为8×8行和列。因此，MAX7219可以在很短的时间内激活每列，同时驱动每一行。因此，通过快速切换列和行，人眼将只注意到连续的光。

注意常见的8×8 LED矩阵的引脚是如何在内部排列的，所以如果你自己构建一个点阵，你应该考虑它。另请注意，MAX7219的公共分线板在5V和IC引脚编号18之间配有一个电阻。该电阻用于设置亮度或流向LED的电流。

IC数据手册中的下表显示了根据LED正向压降我们应该使用的电阻值。

电路原理图

现在让我们将8×8 LED点阵模块连接到Arduino开发板。以下是相关的电路原理图：

点阵模块的VCC和GND连接到Arduino的5V和GND引脚，其他三个引脚，DIN、CLK和CS连接到Arduino开发板的任意数字引脚。如果想连接多个模块，我们只需将前一个分线板的输出引脚连接到新模块的输入引脚即可。实际上这些引脚都是相同的，只是前一个板的DOUT引脚连接到新板的DIN引脚。

此示例所需的组件如下：

●    8×8 LED MAX7219点阵模块

●    HC-05蓝牙模块

●    Arduino开发板

●    面包板和跳线

基本的MAX7219代码

连接模块后，我们就可以看一下第一个例子的Arduino代码了。我们将使用MaxMatrix库，该库可从GitHub下载。

1. /*
   
2.       8x8 LED Matrix MAX7219 Example 01
   
3.    by Dejan Nedelkovski, www.HowToMechatronics.com
   
4.    Based on the following library:
   
5.    GitHub | riyas-org/max7219  https://github.com/riyas-org/max7219
   
6. */
   
7. #include <MaxMatrix.h>
   
8. int DIN = 7;   // DIN pin of MAX7219 module
   
9. int CLK = 6;   // CLK pin of MAX7219 module
   
10. int CS = 5;    // CS pin of MAX7219 module
    
11. int maxInUse = 1;
    
12. MaxMatrix m(DIN, CS, CLK, maxInUse);
    
13. char A[] = {4, 8,
    
14.             B01111110,
    
15.             B00010001,
    
16.             B00010001,
    
17.             B01111110,
    
18.            };
    
19. char B[] = {4, 8,
    
20.             B01111111,
    
21.             B01001001,
    
22.             B01001001,
    
23.             B00110110,
    
24.            };
    
25. char smile01[] = {8, 8,
    
26.                   B00111100,
    
27.                   B01000010,
    
28.                   B10010101,
    
29.                   B10100001,
    
30.                   B10100001,
    
31.                   B10010101,
    
32.                   B01000010,
    
33.                   B00111100
    
34.                  };
    
35. char smile02[] = {8, 8,
    
36.                   B00111100,
    
37.                   B01000010,
    
38.                   B10010101,
    
39.                   B10010001,
    
40.                   B10010001,
    
41.                   B10010101,
    
42.                   B01000010,
    
43.                   B00111100
    
44.                  };
    
45. char smile03[] = {8, 8,
    
46.                   B00111100,
    
47.                   B01000010,
    
48.                   B10100101,
    
49.                   B10010001,
    
50.                   B10010001,
    
51.                   B10100101,
    
52.                   B01000010,
    
53.                   B00111100
    
54.                  };
    
55. void setup() {
    
56.   m.init(); // MAX7219 initialization
    
57.   m.setIntensity(8); // initial led matrix intensity, 0-15
    
58. }
    
59. void loop() {
    
60.   // Seting the LEDs On or Off at x,y or row,column position
    
61.   m.setDot(6,2,true);
    
62.   delay(1000);
    
63.   m.setDot(6,3,true);
    
64.   delay(1000);
    
65.   m.clear(); // Clears the display
    
66.   for (int i=0; i<8; i++){
    
67.     m.setDot(i,i,true);
    
68.     delay(300);
    
69.   }
    
70.   m.clear();
    
71.   // Displaying the character at x,y (upper left corner of the character)  
    
72.   m.writeSprite(2, 0, A);
    
73.   delay(1000);
    
74.   m.writeSprite(2, 0, B);
    
75.   delay(1000);
    
76.   m.writeSprite(0, 0, smile01);
    
77.   delay(1000);
    
78.   
    
79.   m.writeSprite(0, 0, smile02);
    
80.   delay(1000);
    
81.   
    
82.   m.writeSprite(0, 0, smile03);
    
83.   delay(1000);
    
84.   
    
85.   for (int i=0; i<8; i++){
    
86.     m.shiftLeft(false,false);
    
87.     delay(300);
    
88.   }
    
89.   m.clear();
    
90. }

复制代码

代码说明：首先我们需要包含MaxMatrix.h库、定义模块所连接的引脚、设置我们使用的模块数量以及定义MaxMatrix对象。

为了显示字符，我们需要在字符或字节数组中定义它们，这里我举了几个例子。我们可以注意到这些位是如何形成实际为0和1的字符。在本例中，它们被旋转90度，但是库示例建议以这样的方式使用它们，以便以后更容易实现用于滚动文本的shiftLeft自定义函数。

在setup函数部分，我们只需初始化模块以及设置LED的亮度。在loop函数中，通过使用setDot()函数，我们可以点亮任意X、Y或行/列位置的单只LED，并且可以使用clear()函数清除显示。

我们使用writeSprite()函数来显示预定义的字符，该函数的前两个参数是字符左上角的X和Y位置。最后我们使用shiftLeft()函数向左移动或滚动字符。

8×8点阵显示屏滚动的Arduino代码

接下来让我们看看滚动文本的例子，看看有什么不同。在代码下方列出了相关代码的解释。

1. /*
   
2.       8x8 LED Matrix MAX7219 Scrolling Text Example
   
3.    Based on the following library:
   
4.    GitHub | riyas-org/max7219  https://github.com/riyas-org/max7219
   
5. */
   
6. #include <MaxMatrix.h>
   
7. #include <avr/pgmspace.h>
   
8. PROGMEM const unsigned char CH[] = {
   
9.   3, 8, B00000000, B00000000, B00000000, B00000000, B00000000, // space
   
10.   1, 8, B01011111, B00000000, B00000000, B00000000, B00000000, // !
    
11.   3, 8, B00000011, B00000000, B00000011, B00000000, B00000000, // "
    
12.   5, 8, B00010100, B00111110, B00010100, B00111110, B00010100, // #
    
13.   4, 8, B00100100, B01101010, B00101011, B00010010, B00000000, // $
    
14.   5, 8, B01100011, B00010011, B00001000, B01100100, B01100011, // %
    
15.   5, 8, B00110110, B01001001, B01010110, B00100000, B01010000, // &
    
16.   1, 8, B00000011, B00000000, B00000000, B00000000, B00000000, // '
    
17.   3, 8, B00011100, B00100010, B01000001, B00000000, B00000000, // (
    
18.   3, 8, B01000001, B00100010, B00011100, B00000000, B00000000, // )
    
19.   5, 8, B00101000, B00011000, B00001110, B00011000, B00101000, // *
    
20.   5, 8, B00001000, B00001000, B00111110, B00001000, B00001000, // +
    
21.   2, 8, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
    
22.   4, 8, B00001000, B00001000, B00001000, B00001000, B00000000, // -
    
23.   2, 8, B01100000, B01100000, B00000000, B00000000, B00000000, // .
    
24.   4, 8, B01100000, B00011000, B00000110, B00000001, B00000000, // /
    
25.   4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
    
26.   3, 8, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
    
27.   4, 8, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
    
28.   4, 8, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
    
29.   4, 8, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
    
30.   4, 8, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
    
31.   4, 8, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
    
32.   4, 8, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
    
33.   4, 8, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
    
34.   4, 8, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
    
35.   2, 8, B01010000, B00000000, B00000000, B00000000, B00000000, // :
    
36.   2, 8, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
    
37.   3, 8, B00010000, B00101000, B01000100, B00000000, B00000000, // <
    
38.   3, 8, B00010100, B00010100, B00010100, B00000000, B00000000, // =
    
39.   3, 8, B01000100, B00101000, B00010000, B00000000, B00000000, // >
    
40.   4, 8, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
    
41.   5, 8, B00111110, B01001001, B01010101, B01011101, B00001110, // @
    
42.   4, 8, B01111110, B00010001, B00010001, B01111110, B00000000, // A
    
43.   4, 8, B01111111, B01001001, B01001001, B00110110, B00000000, // B
    
44.   4, 8, B00111110, B01000001, B01000001, B00100010, B00000000, // C
    
45.   4, 8, B01111111, B01000001, B01000001, B00111110, B00000000, // D
    
46.   4, 8, B01111111, B01001001, B01001001, B01000001, B00000000, // E
    
47.   4, 8, B01111111, B00001001, B00001001, B00000001, B00000000, // F
    
48.   4, 8, B00111110, B01000001, B01001001, B01111010, B00000000, // G
    
49.   4, 8, B01111111, B00001000, B00001000, B01111111, B00000000, // H
    
50.   3, 8, B01000001, B01111111, B01000001, B00000000, B00000000, // I
    
51.   4, 8, B00110000, B01000000, B01000001, B00111111, B00000000, // J
    
52.   4, 8, B01111111, B00001000, B00010100, B01100011, B00000000, // K
    
53.   4, 8, B01111111, B01000000, B01000000, B01000000, B00000000, // L
    
54.   5, 8, B01111111, B00000010, B00001100, B00000010, B01111111, // M
    
55.   5, 8, B01111111, B00000100, B00001000, B00010000, B01111111, // N
    
56.   4, 8, B00111110, B01000001, B01000001, B00111110, B00000000, // O
    
57.   4, 8, B01111111, B00001001, B00001001, B00000110, B00000000, // P
    
58.   4, 8, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
    
59.   4, 8, B01111111, B00001001, B00001001, B01110110, B00000000, // R
    
60.   4, 8, B01000110, B01001001, B01001001, B00110010, B00000000, // S
    
61.   5, 8, B00000001, B00000001, B01111111, B00000001, B00000001, // T
    
62.   4, 8, B00111111, B01000000, B01000000, B00111111, B00000000, // U
    
63.   5, 8, B00001111, B00110000, B01000000, B00110000, B00001111, // V
    
64.   5, 8, B00111111, B01000000, B00111000, B01000000, B00111111, // W
    
65.   5, 8, B01100011, B00010100, B00001000, B00010100, B01100011, // X
    
66.   5, 8, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
    
67.   4, 8, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
    
68.   2, 8, B01111111, B01000001, B00000000, B00000000, B00000000, // [
    
69.   4, 8, B00000001, B00000110, B00011000, B01100000, B00000000, // \ backslash
    
70.   2, 8, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
    
71.   3, 8, B00000010, B00000001, B00000010, B00000000, B00000000, // hat
    
72.   4, 8, B01000000, B01000000, B01000000, B01000000, B00000000, // _
    
73.   2, 8, B00000001, B00000010, B00000000, B00000000, B00000000, // `
    
74.   4, 8, B00100000, B01010100, B01010100, B01111000, B00000000, // a
    
75.   4, 8, B01111111, B01000100, B01000100, B00111000, B00000000, // b
    
76.   4, 8, B00111000, B01000100, B01000100, B00101000, B00000000, // c
    
77.   4, 8, B00111000, B01000100, B01000100, B01111111, B00000000, // d
    
78.   4, 8, B00111000, B01010100, B01010100, B00011000, B00000000, // e
    
79.   3, 8, B00000100, B01111110, B00000101, B00000000, B00000000, // f
    
80.   4, 8, B10011000, B10100100, B10100100, B01111000, B00000000, // g
    
81.   4, 8, B01111111, B00000100, B00000100, B01111000, B00000000, // h
    
82.   3, 8, B01000100, B01111101, B01000000, B00000000, B00000000, // i
    
83.   4, 8, B01000000, B10000000, B10000100, B01111101, B00000000, // j
    
84.   4, 8, B01111111, B00010000, B00101000, B01000100, B00000000, // k
    
85.   3, 8, B01000001, B01111111, B01000000, B00000000, B00000000, // l
    
86.   5, 8, B01111100, B00000100, B01111100, B00000100, B01111000, // m
    
87.   4, 8, B01111100, B00000100, B00000100, B01111000, B00000000, // n
    
88.   4, 8, B00111000, B01000100, B01000100, B00111000, B00000000, // o
    
89.   4, 8, B11111100, B00100100, B00100100, B00011000, B00000000, // p
    
90.   4, 8, B00011000, B00100100, B00100100, B11111100, B00000000, // q
    
91.   4, 8, B01111100, B00001000, B00000100, B00000100, B00000000, // r
    
92.   4, 8, B01001000, B01010100, B01010100, B00100100, B00000000, // s
    
93.   3, 8, B00000100, B00111111, B01000100, B00000000, B00000000, // t
    
94.   4, 8, B00111100, B01000000, B01000000, B01111100, B00000000, // u
    
95.   5, 8, B00011100, B00100000, B01000000, B00100000, B00011100, // v
    
96.   5, 8, B00111100, B01000000, B00111100, B01000000, B00111100, // w
    
97.   5, 8, B01000100, B00101000, B00010000, B00101000, B01000100, // x
    
98.   4, 8, B10011100, B10100000, B10100000, B01111100, B00000000, // y
    
99.   3, 8, B01100100, B01010100, B01001100, B00000000, B00000000, // z
    
100.   3, 8, B00001000, B00110110, B01000001, B00000000, B00000000, // {
     
101.   1, 8, B01111111, B00000000, B00000000, B00000000, B00000000, // |
     
102.   3, 8, B01000001, B00110110, B00001000, B00000000, B00000000, // }
     
103.   4, 8, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
     
104. };
     
105. int DIN = 7;   // DIN pin of MAX7219 module
     
106. int CLK = 6;   // CLK pin of MAX7219 module
     
107. int CS = 5;    // CS pin of MAX7219 module
     
108. int maxInUse = 2;
     
109. MaxMatrix m(DIN, CS, CLK, maxInUse);
     
110. byte buffer[10];
     
111. char text[]= "HowToMechatronics.com  "; // Scrolling text
     
112. void setup() {
     
113.   m.init(); // module initialize
     
114.   m.setIntensity(15); // dot matix intensity 0-15
     
115. }
     
116. void loop() {
     
117.   printStringWithShift(text, 100); // (text, scrolling speed)
     
118. }
     
119. // Display=the extracted characters with scrolling
     
120. void printCharWithShift(char c, int shift_speed) {
     
121.   if (c < 32) return;
     
122.   c -= 32;
     
123.   memcpy_P(buffer, CH + 7 * c, 7);
     
124.   m.writeSprite(32, 0, buffer);
     
125.   m.setColumn(32 + buffer[0], 0);
     
126.   for (int i = 0; i < buffer[0] + 1; i++)
     
127.   {
     
128.     delay(shift_speed);
     
129.     m.shiftLeft(false, false);
     
130.   }
     
131. }
     
132. // Extract the characters from the text string
     
133. void printStringWithShift(char* s, int shift_speed) {
     
134.   while (*s != 0) {
     
135.     printCharWithShift(*s, shift_speed);
     
136.     s++;
     
137.   }
     
138. }

复制代码

代码说明：代码中的PROGMEN是可变修饰符，用于将数据存储在闪存而不是SRAM中，我们必须为它添加一个额外的库。当我们拥有一个更大的静态变量数据库时，就像在本例中定义字母和字符一样，最好将它们存储在闪存中，因为它比SRAM的2K字节大得多，32K字节。

接下来是字符数组，我们定义滚动文本，在loop函数部分中自定义函数printStringWithShift，使用第二个参数以毫秒定义的滚动速度打印LED矩阵上的滚动文本。这个自定义函数的第一件事是它从文本字符串中提取字符，然后在led矩阵上显示这些滚动字符。

用于通过蓝牙控制8×8 LED矩阵的Android应用程序

我们在了解了MAX7219的工作原理之后，现在可以制作第三个实例，这是一个实用的Arduino项目，我们将构建一个定制的Android应用程序，通过蓝牙通信控制LED点阵。

以下是Arduino代码，现在让我们看看与前一个示例相比的修改。 main.rar (2.25 KB, 下载次数: 45)

2018-11-13 21:41 上传

点击文件名下载附件

代码说明：首先我们需要包含SoftwareSerial.h库，它将启用蓝牙通信并定义程序所需的一些变量。在setup函数部分，我们需要以每秒38400位的默认波特率初始化蓝牙。我将初始文本消息设置为“HowToMechatronics.com”，延迟滚动速度为100毫秒。

接下来，在loop函数部分中，使用Bluetooth.available()函数检查是否有来自串口的输入数据，如果有数据，我们使用Bluetooth.read()函数开始读取串口，每次迭代一个字节。因此，第一个输入字节将始终存储在“indicator”变量中，并根据它选择是否更改文本消息、滚动速度或LED矩阵的亮度。

如果我们看看Android应用程序代码块，我们可以注意到，当单击“发送”按钮时，首先我们发送指示字节，在这种情况下为“1”，这意味着我们希望更改文本消息。为了做到这一点，在Arduino中，我们将清除整个字符阵列并清除LED矩阵显示。然后在“while”循环中，我们将读取串行端口中的其余数据，这是在Android应用程序的文本框中键入的消息。

如果指示变量为“2”，这意味着我们已经改变了滚动速度滑块的位置，因此我们将使用Bluetooth.readString()函数读取其新值并调整滚动速度。我们以同样的方式调整LED的亮度。

以上就是本篇文章的全部内容，如果您有任何疑问，可以在本帖下面进行回复。