功能介绍

MAX7219点阵显示模块是采用MAX7219驱动芯片对一片8x8的点阵LED屏实现驱动点亮的显示模块。MAX7219驱动芯片一片集成化的串行输入/输出共阴极显示驱动器，可以连接条线图显示器或者64个独立的LED。该芯片可以实现信号的联级驱动，也就是可以多个MAX7219显示模块之间串联起来使用，在使用时，串联的所有模块都只需要3个Arduino引脚就可以完成所有模块的显示。因为模块可以串联使用，所以市面上也有直接设计成多个8x8点阵一体的模块，使用时将会省去模块间的接线，更为方便。的供电电压为5VDC。MAX7219点阵显示模块实物如图3.19.1所示。
3.19 MAX7219点阵显示模块 - 图13.19 MAX7219点阵显示模块 - 图2
3.19 MAX7219点阵显示模块 - 图33.19 MAX7219点阵显示模块 - 图4
图3.19.1 MAX7219点阵显示模块实物图

接线说明

Arduino MAX7219显示模块 说明
VCC/+/5V VCC/+/5V 供电引脚
GND/G/- GND/G/- 电源地线
D11 DIO IDE编程时根据不同的库，使用引脚不同，Mixly编程时智能使用改表格中的引脚
D9 CS
D13 CLK

使用说明：

1.按照接线说明完成接线，注意供电引脚必须连接正确。
2(a).Arduino IDE编程
采用Arduino IDE编程时，需要用到库文件，可以通过Arduino IDE的“库管理器”查找所需要的库使用。在“库管理器”中可以搜索“MAX7219”关键词会得到多个和MAX7219相关的库，可以根据自己的情况选择合适的库使用，但是以上搜索得到的库或多或少都存在一些问题，在此推荐一个库“LedControl”，该库可以用于使用MAX7221和MAX7219驱动的SPI总线88 LED显示屏及7段LED数码管。定义一个对象最多可以驱动8块88LED显示屏（每块64个LED，总共512个）或8个7段数码管，需占用三个Arduino的IO口。如需驱动超过8个设备只能定义多个对象，但需要占用更多的IO口。这个库文件，只是可以设定屏上哪个LED点亮哪个LED点灭，想要让LED点阵像跑马灯一样显示出动态效果，需要自己编写相应的程序。对于该库的具体使用方法，可以参考链接：https://www.yuque.com/docs/share/233b5b82-1469-47c5-bf59-85cde80603b6?# 《LedControl库使用说明》 。
对于MAX7219点阵屏的使用，本人采用直接数字口驱动的方式写了一个例程，实现滚动显示数字0-9，详细代码请参看参考程序。
2(b).Mixly编程
采用Mixly编程时，MAX7219点阵显示模块在“显示器”—>“点阵屏”下，展开后将会有多个个MAX7219点阵显示模块相关的程序模块，其中MAX7219点阵初始化模块为必须的程序模块，它用来设置连接到Arduino主板的点阵模块的硬件信息，其中连接的3个引脚中“CS”引脚为可变引脚，其余两个引脚为不可改变引脚，直接使用默认引脚连接即可；“水平点阵屏数”和“竖直点阵屏数”默认为1，也就是单个8x8点阵屏的模块。使用时按照实际连接数设置。其他MAX7219点阵的程序模块为非必须模块，使用时参照程序模块的文字描述使用，模块的文字描述足以说明程序模块的功能了，在此不在详细介绍。具体使用方法请参看参考程序。

参考程序：

Arduino 参考程序

MAX7219的参考程序在此给出两个样例程序，样例程序一是基于LedControl库编写的，实现亮度16级调节，并显示当前的亮度等级；样例程序二是直接采用Arduino的数字接口方式，直接编写MAX7219驱动函数来实现滚动显示数字0-9。样例程序二的驱动函数是根据MAX7219芯片数据手册编写，需要了解更多的硬件知识。
样例程序一：

  1. #include <LedControl.h>
  2. //定义MAX7219的硬件连接接口
  3. int DIN = 11;
  4. int CS = 7;
  5. int CLK = 13;
  6. //定义显示字符数组0-9，a-f
  7. byte s0[8] = {0x00, 0x38, 0x44, 0x44, 0x44, 0x44, 0x44, 0x38}; //0
  8. byte s1[8] = {0x00, 0x30, 0x10, 0x10, 0x10, 0x10, 0x10, 0x38}; //1
  9. byte s2[8] = {0x00, 0x78, 0x08, 0x08, 0x78, 0x40, 0x40, 0x78}; //2
  10. byte s3[8] = {0x00, 0x78, 0x08, 0x08, 0x78, 0x08, 0x08, 0x78}; //3
  11. byte s4[8] = {0x00, 0x08, 0x18, 0x28, 0x48, 0x7C, 0x08, 0x08}; //4
  12. byte s5[8] = {0x00, 0x78, 0x40, 0x40, 0x78, 0x08, 0x08, 0x78}; //5
  13. byte s6[8] = {0x00, 0x78, 0x40, 0x40, 0x78, 0x48, 0x48, 0x78}; //6
  14. byte s7[8] = {0x00, 0x78, 0x48, 0x08, 0x08, 0x08, 0x08, 0x08}; //7
  15. byte s8[8] = {0x00, 0x78, 0x48, 0x48, 0x78, 0x48, 0x48, 0x78}; //8
  16. byte s9[8] = {0x00, 0x78, 0x48, 0x48, 0x78, 0x08, 0x08, 0x78}; //9
  17. byte z_a[8] = {0x00, 0x38, 0x44, 0x44, 0x44, 0x7C, 0x44, 0x44}; //A
  18. byte z_b[8] = {0x00, 0x40, 0x40, 0x40, 0x70, 0x48, 0x48, 0x70}; //b
  19. byte z_c[8] = {0x00, 0x38, 0x44, 0x40, 0x40, 0x40, 0x44, 0x38}; //c
  20. byte z_d[8] = {0x00, 0x78, 0x24, 0x24, 0x24, 0x24, 0x24, 0x78}; //D
  21. byte z_e[8] = {0x00, 0x40, 0x40, 0x78, 0x40, 0x40, 0x78}; //E
  22. byte z_f[8] = {0x00, 0x78, 0x40, 0x40, 0x70, 0x40, 0x40, 0x40}; //F
  24. byte smile[8] =   {0x3C, 0x42, 0xA5, 0x81, 0xA5, 0x99, 0x42, 0x3C}; //笑脸
  25. byte neutral[8] = {0x3C, 0x42, 0xA5, 0x81, 0xBD, 0x81, 0x42, 0x3C}; //标准脸
  26. //创建一个对象，名称是lc
  27. LedControl lc = LedControl(DIN, CLK, CS, 4);
  28. byte i = 0;
  30. void setup() {
  31.   lc.shutdown(0, false);      //启动时，MAX72XX处于省电模式
  32.   lc.setIntensity(0, 8);      //将亮度设置为8
  33.   lc.clearDisplay(0);         //清除显示
  34. }
  36. void loop() {
  37.   lc.setIntensity(0, i);  //亮度设置
  38.   printByte(neutral);//显示标准脸
  39.   delay(1000);
  40.   switch (i) {
  41.     case 0: printByte(s0); //显示0
  42.       break;
  43.     case 1: printByte(s1); //显示1
  44.       break;
  45.     case 2: printByte(s2);
  46.       break;
  47.     case 3: printByte(s3);
  48.       break;
  49.     case 4: printByte(s4);
  50.       break;
  51.     case 5: printByte(s5);
  52.       break;
  53.     case 6: printByte(s6);
  54.       break;
  55.     case 7: printByte(s7);
  56.       break;
  57.     case 8: printByte(s8);
  58.       break;
  59.     case 9: printByte(s9);
  60.       break;
  61.     case 10: printByte(z_a);
  62.       break;
  63.     case 11: printByte(z_b);
  64.       break;
  65.     case 12: printByte(z_c);
  66.       break;
  67.     case 13: printByte(z_d);
  68.       break;
  69.     case 14: printByte(z_e);
  70.       break;
  71.     case 15: printByte(z_f);
  72.       break;
  73.   }
  74.   delay(1000);
  75.   printByte(smile);//显示标准脸
  76.   delay(1000);
  77.   i++;
  78.   if (i > 15)i = 1;
  80. }
  82. //点阵显示函数
  83. void printByte(byte character [])
  84. {
  85.   int i = 0;
  86.   for (i = 0; i < 8; i++)
  87.   {
  88.     lc.setRow(0, i, character[i]);
  89.   }
  90. }

样例程序二：

  1. /*-------------------------------------------
  2.  * Arduino nano板驱动max7219点阵显示
  3.  * 滚动显示数字0-9
  4.  * 显示方式有5种
  5.  * 0-普通显示，直接显示数字
  6.  * 1-滚动显示，出现：下方，消失：上方
  7.  * 2-滚动显示，出现：下方，消失：下方
  8.  * 3-滚动显示，出现：上方，消失：下方
  9.  * 4-滚动显示，出现：上方，消失：上方
  10.  * 作者：@毕世良
  11.  * 时间：2020年1月9
  12.  * 
  13.  ------------------------------------------*/
  14. int Max7219_pin_CLK=13;
  15. int Max7219_pin_CS=7;
  16. int Max7219_pin_DIN=11;
  18. byte disp[9]={0};  //显示缓存区，每次刷新前需要更新
  19. byte static disp1[11][9]={
  20. {0x00,0x1C,0x22,0x22,0x22,0x22,0x22,0x1C},//0/
  21. {0x00,0x08,0x0C,0x0A,0x08,0x08,0x08,0x1E},//1/
  22. {0x00,0x1E,0x10,0x10,0x1E,0x02,0x02,0x1E},//2/
  23. {0x00,0x1E,0x10,0x10,0x1E,0x10,0x10,0x1E},//3/
  24. {0x08,0x0C,0x0A,0x09,0x1F,0x08,0x1E,0x00},//4/
  25. {0x00,0x1E,0x02,0x02,0x1E,0x10,0x10,0x1E},//5/
  26. {0x00,0x1E,0x02,0x02,0x1E,0x12,0x12,0x1E},//6/
  27. {0x00,0x1E,0x12,0x08,0x08,0x08,0x08,0x08},//7/
  28. {0x00,0x1E,0x12,0x12,0x1E,0x12,0x12,0x1E},//8/
  29. {0x00,0x1E,0x12,0x12,0x1E,0x10,0x10,0x1E},//9/
  30. };
  31. //--------------------------------------------
  32. //功能：向MAX7219(U3)写入字节
  33. //入口参数：DATA    要写入的数据
  34. //出口参数：无
  35. //说明：
  36. void Write_Max7219_byte(byte DATA)         
  37. {
  38.     byte i;   
  39.     digitalWrite(Max7219_pin_CS,LOW);   
  40.       for(i=8;i>=1;i--){               //串行数据写入max7219芯片内     
  41.           digitalWrite(Max7219_pin_CLK,LOW); 
  42.           if((DATA&0x80)==0x80){            //如果要写的这位为高
  43.               digitalWrite(Max7219_pin_DIN,HIGH);     
  44.           }
  45.           else{                            //否则
  46.               digitalWrite(Max7219_pin_DIN,LOW);     
  47.           }
  48.           DATA=DATA<<1;                //要写入的数据左移一位
  49.           digitalWrite(Max7219_pin_CLK,HIGH); 
  50.        }                                 
  51. }
  53. //-------------------------------------------
  54. //功能：向MAX7219写入数据
  55. //入口参数：address：要写入的地址0-9、dat：要写入的数据 8位
  56. //出口参数：无
  57. //说明：
  58. void Write_Max7219(byte address,byte dat)
  59. { 
  60.     digitalWrite(Max7219_pin_CS,LOW); 
  61.     Write_Max7219_byte(address);      //写入地址，即数码管编号
  62.     Write_Max7219_byte(dat);         //写入数据，即数码管显示数字 
  63.     digitalWrite(Max7219_pin_CS,HIGH);                       
  64. }
  65. //***************************
  66. //max7219初始化函数
  67. //*************************
  68. void Init_MAX7219(void)
  69. {
  70.  Write_Max7219(0x09, 0x00);       //译码方式：BCD码
  71.  Write_Max7219(0x0a, 0x03);       //亮度 
  72.  Write_Max7219(0x0b, 0x07);       //扫描界限；8个数码管显示
  73.  Write_Max7219(0x0c, 0x01);       //掉电模式：0，普通模式：1
  74.  Write_Max7219(0x0f, 0x00);       //显示测试：1；测试结束，正常显示：0
  75. }
  77. //*************************
  78. //max7219滚动显示函数一个数字函数
  79. //参数：number  需要显示的数字    
  80. //mode：显示模式，1-从下向上出现，向上消失 2-从下向上出现,向下消失 3-从上向下出现，向下消失 4-从上向下出现，向上消失  0-普通显示，直接出来
  81. //显示向上滚动
  82. //******************************
  83. void disp_number(byte numbre_dat,byte mode1){
  84.     byte i,j,k;
  85.   if(mode1==0){                     // 0 直接显示
  86.     for(k=0;k<8;k++){
  87.       disp[k]=disp1[numbre_dat][7-k];
  88.     }
  89.     for(i=1;i<9;i++){           //写数据到MAX7219芯片
  90.       Write_Max7219(i,disp[i-1]);  
  91.     } 
  92.     delay(500);  
  93.   }
  94.   else if(mode1==1){
  95.     for(j=0;j<16;j++){    
  96.       if(j<8){                               // 1 出现方式  ，自下而上
  97.         if(j==0){
  98.           disp[0]=disp1[numbre_dat][j];
  99.         } 
  100.         else{
  101.           for(k=j;k>0;k--){
  102.             disp[k]=disp[k-1];
  103.           } 
  104.           disp[0]=disp1[numbre_dat][j];           
  105.         }   
  106.       } 
  107.       else{                                    // 1 消失的方式   向上
  108.         for(k=7;k>0;k--){
  109.           disp[k]=disp[k-1];
  110.         }
  111.         disp[0]=0;
  112.       }
  113.       for(i=1;i<9;i++){           //写数据到MAX7219芯片
  114.         Write_Max7219(i,disp[i-1]);
  115.         delay(10);    
  116.       } 
  117.       if(j==7){delay(400);} 
  118.     }
  119.   }
  120.   else if(mode1==2){
  121.     for(j=0;j<16;j++){      
  122.       if(j<8){                               // 2 出现方式  ，自下而上
  123.         if(j==0){
  124.             disp[0]=disp1[numbre_dat][j];
  125.         } 
  126.         else{
  127.           for(k=j;k>0;k--){
  128.             disp[k]=disp[k-1];
  129.           } 
  130.           disp[0]=disp1[numbre_dat][j];           
  131.         }   
  132.       } 
  133.       else{                         // 2 消失的方式   向下
  134.         for(k=0;k<8;k++){
  135.           disp[k]=disp[k+1];
  136.         }
  137.         disp[7]=0;
  138.       }
  139.       for(i=1;i<9;i++){                //写数据到MAX7219芯片
  140.         Write_Max7219(i,disp[i-1]);
  141.         delay(10);    
  142.       } 
  143.       if(j==7){delay(400);}             //当显示完整后等待一下
  144.     }
  145.   }
  146.   else if(mode1==3){
  147.     for(j=0;j<16;j++){                                  
  148.       if(j<8){                // 3 出现方式，自上而下
  149.         if(j==0){
  150.           disp[7]=disp1[numbre_dat][7-j];
  151.         } 
  152.         else{
  153.           for(k=j;k>0;k--){
  154.             disp[7-k]=disp[7-k+1];
  155.           } 
  156.           disp[7]=disp1[numbre_dat][7-j];           
  157.         }   
  158.       } 
  159.       else{                        // 3 消失方式，向上       
  160.         for(k=0;k<8;k++){
  161.           disp[k]=disp[k+1];
  162.         }
  163.         disp[7]=0;
  164.       }
  165.       for(i=1;i<9;i++){           //写数据到MAX7219芯片
  166.         Write_Max7219(i,disp[i-1]);
  167.         delay(10);    
  168.       } 
  169.       if(j==7){delay(400);} 
  170.     }
  171.   }
  172.   else if(mode1==4){
  173.     for(j=0;j<16;j++){                                  
  174.       if(j<8){                // 4 出现方式，自上而下
  175.         if(j==0){
  176.           disp[7]=disp1[numbre_dat][7-j];
  177.         } 
  178.         else{
  179.           for(k=j;k>0;k--){
  180.             disp[7-k]=disp[7-k+1];
  181.           } 
  182.           disp[7]=disp1[numbre_dat][7-j];           
  183.         }   
  184.       } 
  185.       else{                   // 4 消失方式，向下      
  186.         for(k=7;k>0;k--){
  187.           disp[k]=disp[k-1];
  188.         }
  189.         disp[0]=0;
  190.       }
  191.       for(i=1;i<9;i++){           //写数据到MAX7219芯片
  192.         Write_Max7219(i,disp[i-1]);
  193.         delay(10);    
  194.       } 
  195.       if(j==7){delay(400);} 
  196.     }
  197.   }
  198. }
  201. void setup() {
  202.   pinMode(Max7219_pin_CS,OUTPUT);
  203.   pinMode(Max7219_pin_CLK,OUTPUT);
  204.   pinMode(Max7219_pin_DIN,OUTPUT); 
  205.   Init_MAX7219();                    //初始化MAX7219芯片
  206. }
  208. void loop() {
  209.     disp_number(0,1);     //模式1
  210.     delay(100);   
  211.     disp_number(1,1);
  212.     delay(100);    
  213.     disp_number(2,2);     //模式2
  214.     delay(100);    
  215.     disp_number(3,2);
  216.     delay(100); 
  217.     disp_number(4,3);    //模式3
  218.     delay(100); 
  219.     disp_number(5,3);
  220.     delay(100); 
  221.     disp_number(6,4);    //模式4
  222.     delay(100); 
  223.     disp_number(7,4);
  224.     delay(100); 
  225.     disp_number(8,0);   //模式0  普通显示
  226.     delay(100); 
  227.     disp_number(9,0);
  228.     delay(100); 
  230. }

样例程序二是直接采用digitalWrite()函数实现数据串行写入MAX7219芯片，其实Arduino官方已经写好了一个函数“shiftout”，用该函数同样可以实现数据的串行写入芯片内，该函数的使用方法请参照附录2中常用函数。

Mixly参考程序

3.19 MAX7219点阵显示模块 - 图5
以上参考程序实现在MAX7219点阵显示屏上滚动显示“Arduino”几个字符2S时间，再显示一个斜向的双向箭头符号2S时间，再显示字幕“M”2S时间，最后关闭显示2S时间，如此循环。