在本篇文章中，您将学习如何使用基于MAX7219的8×8点阵LED模块。通过本文，您将能够轻松实现固定或滚动显示一个或多个点阵上的任何形状或文本，并且只使用Arduino开发板的4个数字引脚。

什么是点阵？

8×8点阵LED是一组LED，您可以在其上显示特定的数字、字母和形状。点阵由行数和列数表示。最受欢迎的点阵式是8×8型，可提供8行8列共计64个LED。

要实现简单地控制点阵8×8，您应该将每行和每列连接到数字引脚，这意味着您需要16个数字引脚！所以这不是一个正确的方法。

为了控制点阵，基于MAX72xx的模块需要连接到4个数字引脚而不是16个。您还可以将多个点阵（最多8个）相互连接，无需任何额外的引脚并级联它们。

如何使用Arduino连接点阵模块

所需的材料

●    Arduino Uno R3开发板

●    MAX7219点阵显示模块

●    Arduino IDE

电路

要将点阵连接到Arduino，只需将Vcc和GND引脚连接到Arduino的5V和GND，点阵的DIN、CS和CLK引脚可以连接到arduino的任意数字引脚。

代码

基于Arduino的Dot matrix有各种各样的库。 Ledcontrol和MaxMatrix库是两个最常见的库，两者都具有相同的结构。

现在上传以下代码到Arduino开发板中。

1. /*
   
2.   8x8 Dot Matrix w/ MAX7219
   
3.   modified on 7 March 2019
   
4.   by Saeed Hosseini @ Electropeak
   
5.   https://electropeak.com/learn/
   
6. */
   
7. #include <MaxMatrix.h>
   
8. 
   
9. 
   
10. int DIN = 7;
    
11. int CLK = 6;
    
12. int CS = 5;
    
13. int maxInUse = 1;
    
14. 
    
15. byte buffer[20];
    
16. char text[] = "a";
    
17. 
    
18. MaxMatrix m(DIN, CS, CLK, maxInUse);
    
19. 
    
20. void setup() {
    
21.   m.init();
    
22.   m.setIntensity(8);
    
23. }
    
24. void loop() {
    
25.   m.setDot(0, 7, true);
    
26. 
    
27.   m.setDot(0, 7, true);
    
28.   delay(1000);
    
29.   m.setDot(7, 0, true);
    
30.   delay(1000);
    
31.   m.setColumn(3, B11110000);
    
32.   delay(1000);
    
33.   m.setColumn(4, B00001111);
    
34.   delay(1000);
    
35.   m.clear();
    
36.   delay(1000);
    
37. }

复制代码

在点阵上显示特定形状

要在点阵上显示特定形状，只需将LED灯图案转换为位串即可。为此，您可以从一些在线工具中获得支持。设计你的形状并将生成的代码复制到Arduino，然后将其上传到你的开发板上。

1. /*
   
2.   8x8 Dot Matrix w/ MAX7219
   
3.   modified on 7 March 2019
   
4.   by Saeed Hosseini @ Electropeak
   
5.   https://electropeak.com/learn/
   
6. */
   
7. #include <MaxMatrix.h>
   
8. 
   
9. int DIN = 7;
   
10. int CLK = 6;
    
11. int CS = 5;
    
12. int maxInUse = 1;
    
13. 
    
14. MaxMatrix m(DIN, CS, CLK, maxInUse);
    
15. 
    
16. byte poker[] = {8, 8,
    
17.                 0xff,
    
18.                 0x81,
    
19.                 0xa5,
    
20.                 0xa1,
    
21.                 0xa1,
    
22.                 0xa5,
    
23.                 0x81,
    
24.                 0xff
    
25.                };
    
26. byte smile[] = {8, 8,
    
27.                 0xff,
    
28.                 0x81,
    
29.                 0xb5,
    
30.                 0xa1,
    
31.                 0xa1,
    
32.                 0xb5,
    
33.                 0x81,
    
34.                 0xff
    
35.                };
    
36. byte sad[] = {8, 8,
    
37.               0xff,
    
38.               0x81,
    
39.               0xb5,
    
40.               0x91,
    
41.               0x91,
    
42.               0xb5,
    
43.               0x81,
    
44.               0xff
    
45.              };
    
46. byte kiss[] = {8, 8,
    
47.                0xff,
    
48.                0x81,
    
49.                0xb5,
    
50.                0xb1,
    
51.                0xb1,
    
52.                0xb5,
    
53.                0x81,
    
54.                0xff
    
55.               };
    
56. void setup() {
    
57.   m.init();
    
58.   m.setIntensity(8);
    
59. }
    
60. void loop() {
    
61.   m.writeSprite(0, 0, smile);
    
62.   delay(1000);
    
63.   m.clear();
    
64.   m.writeSprite(0, 0, poker);
    
65.   delay(1000);
    
66.   m.clear();
    
67.   m.writeSprite(0, 0, sad);
    
68.   delay(1000);
    
69.   m.clear();
    
70.   m.writeSprite(0, 0, kiss);
    
71.   delay(1000);
    
72.   for (int i = 0; i < 8; i++) {
    
73.     m.shiftLeft(false, false);
    
74.     delay(300);
    
75.   }
    
76.   m.clear();
    
77. }

复制代码

您还可以通过此方法创建和显示数字和字母。

要插入常用数字、字母和符号，可以使用以下字符串和函数：

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

复制代码

级联两个点阵LED模块

Dot Matrix模块的一个有趣功能是能够连接多个（最多8个）模块并在其上显示级联信息。

电路

将Dout从第一个模块连接到下一个模块的Din，并将其他具有相同名称的引脚彼此连接。

代码

现在上传以下代码到Arduino中，然后查看结果。

1. /*
   
2.   8x8 Dot Matrix w/ MAX7219
   
3.   modified on 7 March 2019
   
4.   by Saeed Hosseini @ Electropeak
   
5.   https://electropeak.com/learn/
   
6. */
   
7. #include <MaxMatrix.h>
   
8. 
   
9. int DIN = 7;
   
10. int CLK = 6;
    
11. int CS = 5;
    
12. int maxInUse = 2;
    
13. 
    
14. MaxMatrix m(DIN, CS, CLK, maxInUse);
    
15. 
    
16. byte pakman[] = {8, 8, 0x1c, 0x22, 0x41, 0x49, 0x55, 0x22, 0x00, 0x08};
    
17. 
    
18. void setup() {
    
19.   m.init();
    
20.   m.setIntensity(2);
    
21. }
    
22. void loop(){
    
23.   m.writeSprite(0, 0, pakman);
    
24.   delay(300);
    
25.   for (int i = 0; i < 8; i++) {
    
26.     m.shiftRight(false, true);
    
27.     delay(300);
    
28.   }
    
29.   m.clear();
    
30. 
    
31. }

复制代码

以上就是本篇文章的全部内容。如遇到问题，请随时在本帖下面进行回复。