电子制作实现，点阵LED的动态点亮控制

在电子制作中，点阵LED可以堪称为标准配件。使用点阵LED，可以用很少的引脚控制大量LED。在本文中，我们将为您介绍点阵LED的典型控制方式——动态点亮控制。

目录

• 用大量LED显示字符和图像！在电子制作中如何实现？
• 控制多个LED的“动态点亮控制”
• Arduino与点阵LED的接线
• 先了解动态点亮的基本工作
• 通过数组控制LED点亮
• 滑动显示字符使其像电子广告牌一样工作
• 增加LED的数量并进行复杂的控制
  

用大量LED显示字符和图像！在电子制作中如何实现？

如果您仔细观察街角和车站的电子广告牌，就会发现是通过上面很多呈网格状排列的LED分别点亮来显示字符和图像的。
稍微接触过像Arduino这样的微控制器开发板的人可能会想知道，他们是如何用只有几十个引脚的微控制器来控制几百乃至几千个LED的？
在本文中，我们将介绍使用点阵LED（电子制作中常用的典型电子组件）用很少的引脚控制大量LED的动态点亮控制。


控制多个LED的“动态点亮控制”
动态点亮控制是通过高速切换LED的点亮状态，使其看起来像多个LED同时点亮的一种控制方式。例如，当在1秒内对多个LED的点亮进行几百次切换时，人眼会觉得这些LED是同时点亮的。通过这种点亮控制，就可以用很少的微控制器板引脚控制很多LED。
这种动态点亮控制常用的是点阵LED，即以矩阵状排列多个LED。通过与动态点亮控制相结合，只需很少的布线即可实现各种LED点亮模式。

Arduino与点阵LED的接线

这次我们将介绍在电子制作中经常使用的8列x8行共64个LED的点阵LED的使用方法。这个点阵LED的布线包括列和行在内只有16根线。

本次使用的矩阵LED OSL641501-AG的内部布线图。虽有64个LED，但实际布线只有16根。

点阵LED没有用来限制电流的电阻器。我们一边查看技术规格书，一边将8个电阻分别连接到阳极侧或阴极侧吧。
电阻值由Arduino的数字输入输出引脚的电压（5V）、LED固有的正向压降（VF）和LED的亮度（电流）决定。但是，请注意Arduino对可从引脚获取的电流值是有限制的。电阻器连接到阳极侧或阴极侧都可以。

这次Arduino Uno和点阵LED的接线电路图。线比较多，所以电路看起来比较复杂，但未必一定要采用这种接线方式。只需要把握LED的阳极侧和阴极侧即可，布线的差异可以通过草图吸收。

使用Arduino Uno时，布线请避免使用草图写入用的数字0,1（TX、RX）引脚和连接着内置LED的数字13引脚。虽然数字引脚不足，但可将模拟引脚A0～A5分别用作数字引脚D14～D19，这样就足够连接16个引脚。


先了解动态点亮的基本工作

点阵LED接线完成后，需要编写一个草图。首先，需要让点阵LED的所有LED点亮。方法是让1行中的所有LED点亮，并快速切换列，使其看起来像所有LED都点亮了。

1. //矩阵LED引脚顺序
   
2. int anode[8]   = { 15, 4, 5, 11, 7, 12, 17, 18 };
   
3. int cathode[8] = { 10, 16, 9, 14, 2, 8, 3, 6 };
   
4. 
   
5. void setup()
   
6. {
   
7.   //引脚初始化
   
8.   for ( int i = 0; i < 8; ++i )
   
9.   {
   
10.     pinMode( anode[i], OUTPUT );
    
11.     digitalWrite( anode[i], LOW );
    
12.   }
    
13.   for ( int i = 0; i < 8; ++i )
    
14.   {
    
15.     pinMode( cathode[i], OUTPUT );
    
16.     digitalWrite( cathode[i], HIGH );
    
17.   }
    
18. }
    
19. 
    
20. void loop()
    
21. {
    
22.   for ( int i = 0; i < 8; ++i )
    
23.   {
    
24.     digitalWrite( cathode[i], LOW );
    
25.     for ( int j = 0; j < 8; ++j )
    
26.     {
    
27.       digitalWrite( anode[j], HIGH );
    
28.     }
    
29.     //delay(100);
    
30.     for ( int j = 0; j < 8; j++ )
    
31.     {
    
32.       digitalWrite( anode[j], LOW );
    
33.     }
    
34.     digitalWrite( cathode[i], HIGH );
    
35.   }
    
36. }

使用数组和for语句即可对点阵LED编写一个简单的草图。下面简要解说一下程序的流程。
在最开始的anode数组和cathode数组中，分别输入了矩阵LED引脚和Arduino引脚的接线信息。在anode数组中，依次输入了矩阵LED列的引脚。在cathode数组中，依次输入了矩阵LED行的引脚。我们要注意的是，确保所连接的Arduino引脚按照矩阵LED的行列编号顺序保存在数组中。
在接下来的setup函数中，为了定义Arduino中使用的引脚的状态，使用anode和cathode数组以及for语句对每个引脚逐一进行了初始化。
矩阵LED的点亮状态由loop函数控制。如果使用双重for循环语句，将会干净利落地实现矩阵LED的点亮。
在外侧for语句中，将要点亮的行的cathode侧设置为LOW，以便使电流流过整个行。之后，通过内侧for语句按顺序指定要点亮的列。这次需要将所有列的LED都点亮，因此将anode侧全部设置为HIGH。当这些处理完成后，1整行的灯都会亮起。通过对所有的行快速重复该动作，使人看起来好像所有的LED都同时亮起了。
如果启用第29行注释的delay函数，应该可以看到是如何逐行切换显示的。综上所述，我们已经了解了动态点亮是通过快速切换LED的ON/OFF实现看起来像多个LED同时点亮的一种方式。
matrix led 07通过数组控制LED点亮

至此，您应该已经了解了点阵LED的控制机制。然而，仅仅点亮LED是不够的，我们需要让LED的点亮状态能够自由切换！在这次的案例中，我们尝试使之显示DEVICE PLUS的一个字母“D”。
由于LED的ON/OFF控制只需要0和1的数据（boolean型）即可，因此我们使用如下所示的数组来定义字母“D”的点亮数据。我们设要点亮的LED为“1”，要熄灭的LED为“0”，并以点图的方式来定义数组。由于我们使用的是8×8点阵，因此数组也是8×8。

1. boolean matrix[8][8] = {
   
2.   { 0, 1, 1, 1, 1, 0, 0, 0 },
   
3.   { 0, 1, 1, 1, 1, 1, 0, 0 },
   
4.   { 0, 1, 1, 0, 1, 1, 1, 0 },
   
5.   { 0, 1, 1, 0, 0, 1, 1, 0 },
   
6.   { 0, 1, 1, 0, 0, 1, 1, 0 },
   
7.   { 0, 1, 1, 0, 1, 1, 1, 0 },
   
8.   { 0, 1, 1, 1, 1, 1, 0, 0 },
   
9.   { 0, 1, 1, 1, 1, 0, 0, 0 }
   
10. };

下面需要更改草图，以使数组的内容反映在显示中。将双重for语句中的digitalWrite函数更改为引用定义的数组。

1. digitalWrite( anode[j], HIGH );
   
2. ↓
   
3. digitalWrite( anode[j], matrix[i][j] )
   
4. 
   
5. 反映了这些更改的草图如下：
   
6. 
   
7. //矩阵LED引脚顺序
   
8. int anode[8]   = { 15, 4, 5, 11, 7, 12, 17, 18 };
   
9. int cathode[8] = { 10, 16, 9, 14, 2, 8, 3, 6 };
   
10. 
    
11. void setup()
    
12. {
    
13.   //引脚初始化
    
14.   for ( int i = 0; i < 8; ++i )
    
15.   {
    
16.     pinMode( anode[i], OUTPUT );
    
17.     digitalWrite( anode[i], LOW );
    
18.   }
    
19.   for ( int i = 0; i < 8; ++i )
    
20.   {
    
21.     pinMode( cathode[i], OUTPUT );
    
22.     digitalWrite( cathode[i], HIGH );
    
23.   }
    
24. }
    
25. 
    
26. boolean matrix[8][8] = {
    
27.   { 0, 1, 1, 1, 1, 0, 0, 0 },
    
28.   { 0, 1, 1, 1, 1, 1, 0, 0 },
    
29.   { 0, 1, 1, 0, 1, 1, 1, 0 },
    
30.   { 0, 1, 1, 0, 0, 1, 1, 0 },
    
31.   { 0, 1, 1, 0, 0, 1, 1, 0 },
    
32.   { 0, 1, 1, 0, 1, 1, 1, 0 },
    
33.   { 0, 1, 1, 1, 1, 1, 0, 0 },
    
34.   { 0, 1, 1, 1, 1, 0, 0, 0 }
    
35. };
    
36. 
    
37. void loop()
    
38. {
    
39.   // 字符数据的输出处理
    
40.   for ( int i = 0; i < 8; i++ )
    
41.   {
    
42.     digitalWrite( cathode[i], LOW );
    
43.     for ( int j = 0; j < 8; j++ )
    
44.     {
    
45.       digitalWrite( anode[j], matrix[i][j] );
    
46.     }
    
47.     //delay(50);
    
48.     for ( int j = 0; j < 8; j++ )
    
49.     {
    
50.       digitalWrite( anode[j], LOW );
    
51.     }
    
52.     digitalWrite( cathode[i], HIGH );
    
53.   }
    
54. }
    

执行草图程序，LED应会按照数组的内容亮起。与之前的草图一样，如果启用注释的delay函数，就可以看到在逐行绘制D的形状时LED是如何切换的。
草图的处理很简单，即分别读取数组中的“0”和“1”，并控制相应位置的LED的点亮状态。也就是说，只要能够这样读取数组，就可以自由自在地控制LED的点亮状态了。
至此，您应该已经了解了点阵LED的动态点亮控制机制。

滑动显示字符使其像电子广告牌一样工作

当您能够自由自在地控制点阵LED后，接下来可能就会想要实现像电子广告牌一样的效果了。当然，只要您能使用点阵LED和Arduino，就可以切换点亮状态下的显示状态，也可以实现像电子广告牌一样滚动，但这里需要一些草图技巧。
例如，如何才能在进行动态点亮控制的同时使字符以1秒为单位滚动？在这里，如果使用LED闪烁中经常使用的delay函数，微控制器就会停止，动态点亮控制也会停止，无法显示字符。
要想不间断地控制LED，就需要考虑怎样处理才能使微控制器不会停动。而且，要想像电子广告牌那样显示很多字符时，还需要很多数组数据，并需要考虑如何从这些数组中提取要显示的部分。
因此，为了避免微控制器停动，这次我们将添加一个处理：使用millis函数检测经过的时间，同时滚动字符。

1.   if (tm + SCROLL_TIME <= millis()) {
   
2.     for (int i = 0; i < 8 ; i++)  {
   
3.       for (int j = 0; j < 8 ; j++) {
   
4.         matrix[i][j] = matrix_data[i][j + slide];
   
5.       }
   
6.     }
   
7.    
   
8.     //滑动保存位置，到达终点时返回起点
   
9.     if (slide < 49) {
   
10.       ++slide;
    
11.     }
    
12.     else {
    
13.       slide = 0;
    
14.     }
    
15.    
    
16.     //重新检测经过的时间
    
17.     tm = millis();
    
18.   }

如果是滚动显示的话，字符数据的数组也会变大。这次，我们将创建能够滚动显示字符“DEVICE PLUS”的数组数据。

1. boolean matrix_data[8][57] = {
   
2.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
   
3.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1 },
   
4.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0 },
   
5.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0 },
   
6.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0 },
   
7.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1 },
   
8.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1 },
   
9.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0 }
   
10. };

添加了滚动显示功能的草图如下。整个草图的流程是从保存有字符数据的数组中提取要显示部分的数组，并在指定的时间滚动。由于Arduino自始至终不会停止，因此可以始终执行动态点亮控制。

1. //矩阵LED引脚顺序
   
2. int anode[8]   = { 15, 4, 5, 11, 7, 12, 17, 18 };
   
3. int cathode[8] = { 10, 16, 9, 14, 2, 8, 3, 6 };
   
4. 
   
5. //字符数据
   
6. boolean matrix_data[8][57] = {
   
7.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
   
8.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1 },
   
9.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0 },
   
10.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0 },
    
11.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0 },
    
12.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1 },
    
13.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1 },
    
14.   { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0 }
    
15. };
    
16. boolean matrix[8][8] = {};
    
17. 
    
18. //输出用的数组变量
    
19. int slide = 0;
    
20. unsigned long tm = 0;
    
21. 
    
22. //滚动时间
    
23. #define SCROLL_TIME 90 //毫秒
    
24. 
    
25. void setup()
    
26. {
    
27.   //引脚初始化
    
28.   for ( int i = 0; i < 8; ++i )
    
29.   {
    
30.     pinMode( anode[i], OUTPUT );
    
31.     digitalWrite( anode[i], LOW );
    
32.   }
    
33.   for ( int i = 0; i < 8; ++i )
    
34.   {
    
35.     pinMode( cathode[i], OUTPUT );
    
36.     digitalWrite( cathode[i], HIGH );
    
37.   }
    
38.   
    
39.   // 将输出用的数组初始化
    
40.   for (int i = 0; i < 8 ; ++i)  {
    
41.     for (int j = 0; j < 8 ; ++j) {
    
42.       matrix[i][j] = 0;
    
43.     }
    
44.   }
    
45.   
    
46.   //保存初始经过时间
    
47.   tm = millis();
    
48. }
    
49. 
    
50. void loop()
    
51. {
    
52.   //按照每个经过时间将字符数据保存在输出用的数组中
    
53.   if (tm + SCROLL_TIME <= millis()) {
    
54.     for (int i = 0; i < 8 ; i++)  {
    
55.       for (int j = 0; j < 8 ; j++) {
    
56.         matrix[i][j] = matrix_data[i][j + slide];
    
57.       }
    
58.     }
    
59.    
    
60.     //滑动保存位置，到达终点时返回起点
    
61.     if (slide < 49) {
    
62.       ++slide;
    
63.     }
    
64.     else {
    
65.       slide = 0;
    
66.     }
    
67.    
    
68.     //重新检测经过的时间
    
69.     tm = millis();
    
70.   }
    
71. 
    
72.   // 字符数据的输出处理
    
73.   for ( int i = 0; i < 8; i++ )
    
74.   {
    
75.     digitalWrite( cathode[i], LOW );
    
76.     for ( int j = 0; j < 8; j++ )
    
77.     {
    
78.       digitalWrite( anode[j], matrix[i][j] );
    
79.     }
    
80.     //delay(50);
    
81.     for ( int j = 0; j < 8; j++ )
    
82.     {
    
83.       digitalWrite( anode[j], LOW );
    
84.     }
    
85.     digitalWrite( cathode[i], HIGH );
    
86.   }
    
87. }

在这个草图中，可以通过更改第23行的SCROLL_TIME的数字来调整滚动速度。视频因为反光有点不方便看，不过即使将速度提高到70ms，也可以看到字符形状。

增加LED的数量并进行复杂的控制

在使用Arduino直接控制点阵LED的方法中，最大可以控制8×8的点阵LED，这是极限。如果想要控制更大的点阵LED，需要使用专用IC进行通信控制，或使用外部存储器。
乍一看很简单，其实点阵LED是一种比较复杂深奥的电子组件。要想很好地使用它，需要掌握电子元器件和微控制器技术。
处理点阵的技术也可以应用在其他电子元器件上，因此点阵LED可能是非常适合用来学习的电子组件。
无论是用于电子制作还是用来学习，鉴于它是一种很易于买到的电子产品，在购买Arduino时把点阵LED也一起买下来，可能是个不错的选择。