0
0

【蓝桥杯单片机入门记录】动态数码管

一、数码管动态显示概述

  • LED数码管动态显示接口是单片机中应用最为广泛的一种显示方式之一。
  • 动态驱动是将所有数码管的8个显示笔划（段选端）“a,b,c,d,e,fg,dp”的同名端连在一起，另外为每个数码管的公共极COM增加位选通控制电路，位选通由各自独立的I/O线控制。当单片机输出字形码时，单片机先对位选通COM端电路进行控制，再对段选通进行输出，该位就显示出字形，没有选通的数码管就不会亮。
  • 通过分时轮流控制各个数码管的的COM端，就使各个数码管轮流受控显示，这就是动态驱动。
  • 在轮流显示过程中，每位数码管的点亮时间为1~2ms，由于人的视觉暂留现象及发光二极管的余辉效应，尽管实际上各位数码管并非同时点亮，但只要扫描的速度足够快，给人的印象就是一组稳定的显示数据，不会有闪烁感，动态显示的效果和静态显示是一样的，能够节省大量的I/O端口，而且功耗更低。

二、动态数码管原理图

（1）原理图

（2）动态数码管如何与芯片相连

（3）“此器件” ——>锁存器74HC573

  • 74HC573的八个锁存器都是透明的D型锁存器，当使能(G)为高时，0输出将随数据(D)输入而变当使能为低时，将输出锁存在已建立的数据电平上。
  • 输出控制不影响锁存器的内部工作，即老数据可以保持，甚至当输出被关闭时，新的数据也可以置入。
  • 这种电路可以驱动大电容或低阻抗负载，可以直接与系统总线接口并驱动总线，而不需要外接口。特别适用于缓冲寄存器，1/0通道，双向总线驱动器和工作寄存器。
  • Y7C为高电平，a-dp会随着p0变化；Y7C为低电平时，锁存置为低电平的那一刻的数据，不再变化
  • Y7C和Y6C同时只能有一个为低电平

三、动态数码管显示例程

（1）例程1：两个数码管显示不同内容。本例以第一个数码管显示数字“0”，第二个数码管显示数字“1”为例。

  1. //头文件声明区域
  2. #include <STC15F2K60S2.H>
  3. #include<intrins.h>
  5. //变量声明区域
  6. unsigned int i = 0;
  8. //函数声明区域
  9. void Delay(int ms);
  11. //程序主体
  12. void main()
  13. {
  14.     P2=0XA0;P0=0X00;P2=0X80;P0=0XFF;//初始化程序  
  16.     while(1)
  17.     {
  18.         P2=0XC0;P0=0X01;//打开控制数码管位选的锁存器，然后选中第一个数码管
  19.         P2=0XFF;P0=0XC0;//大家控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  20.         Delay(1);
  21.         
  22.         P2=0XC0;P0=0X02;//打开控制数码管位选的锁存器，然后选中第二个数码管
  23.         P2=0XFF;P0=0XF9;//打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  24.         Delay(1);
  25.         
  26.         
  27.     }    
  28.         
  29. }
  31. //函数定义区域
  32. void Delay(int ms)        //@11.0592MHz
  33. {
  34.     unsigned char i, j;
  35.     for(i = 0;i < ms;i++)
  36.     {
  37.         _nop_();
  38.     _nop_();
  39.     _nop_();
  40.     i = 11;
  41.     j = 190;
  42.     do
  43.     {
  44.         while (--j);
  45.     } while (--i);
  46.                 
  47.     }
  48.     
  49. }

（2）例程2：多个数码管显示不同内容（二）。注：创建数码管显示子函数。

  1. #include <STC15F2K60S2.H>
  2. #include<intrins.h>
  4. void Delay_MS(unsigned int MS);
  6. void main(void)
  7. {
  8.     IO_Init();
  9.     
  10.     P2=0XA0;P0=0X00;P2=0X80;P0=0XFF;        //初始化程序，后期详解;
  11.     
  12.     while(1)
  13.     {
  14.         P2=0XC0;P0=0X01;     //打开控制数码管位选的锁存器，然后选中第一个数码管
  15.         P2=0XFF;P0=0XC0;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  16.         Delay_MS(1);
  17.         
  18.         P2=0XC0;P0=0X02;     //打开控制数码管位选的锁存器，然后选中第二个数码管
  19.         P2=0XFF;P0=0XF9;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  20.         Delay_MS(1);
  21.         
  22.         P2=0XC0;P0=0X04;     //打开控制数码管位选的锁存器，然后选中第三个数码管
  23.         P2=0XFF;P0=0XF9;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  24.         Delay_MS(1);
  25.         
  26.         P2=0XC0;P0=0X08;     //打开控制数码管位选的锁存器，然后选中第四个数码管
  27.         P2=0XFF;P0=0XF9;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  28.         Delay_MS(1);
  29.         
  30.         P2=0XC0;P0=0X10;     //打开控制数码管位选的锁存器，然后选中第五个数码管
  31.         P2=0XFF;P0=0XF9;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  32.         Delay_MS(1);
  33.         
  34.         P2=0XC0;P0=0X20;     //打开控制数码管位选的锁存器，然后选中第六个数码管
  35.         P2=0XFF;P0=0XF9;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  36.         Delay_MS(1);
  37.         
  38.         P2=0XC0;P0=0X40;     //打开控制数码管位选的锁存器，然后选中第七个数码管
  39.         P2=0XFF;P0=0XF9;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  40.         Delay_MS(1);
  41.         
  42.         P2=0XC0;P0=0X80;     //打开控制数码管位选的锁存器，然后选中第八个数码管
  43.         P2=0XFF;P0=0XF9;    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  44.         Delay_MS(1);
  45.     }
  46. }
  48. void Delay_MS(unsigned int MS)
  49. {
  50.     unsigned char i, j;
  51.     for(i = 0;i < ms;i++)
  52.     {
  53.         _nop_();
  54.     _nop_();
  55.     _nop_();
  56.     i = 11;
  57.     j = 190;
  58.     do
  59.     {
  60.         while (--j);
  61.     } while (--i);
  62.                 
  63.     }
  64.     
  65. }

（3）例程3：多个数码管显示不同内容（二）。注：创建数码管显示子函数。

①法一：
  1. //头文件声明区域
  2. #include <STC15F2K60S2.H>
  3. #include<intrins.h>
  5. //变量声明区域
  6. unsigned int i = 0;
  7. unsigned char DSEG[]= {0X00,0X01,0X02,0X04,0X08,0X10,0X20,0X40,0X80};
  8. unsigned char code SEG[] = {0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
  10. //函数声明区域
  11. void Delay(int ms);
  12. void DSED_Display(unsigned char dseg,unsigned char seg);
  14. //程序主体
  15. void main()
  16. {
  17.     P2=0XA0;P0=0X00;P2=0X80;P0=0XFF;//初始化程序  
  18.     
  19.     while(1)
  20.     {
  21.      DSED_Display(1,1);
  22.    DSED_Display(2,2);
  23.      DSED_Display(3,3);
  24.      DSED_Display(4,4);
  25.      DSED_Display(5,5);
  26.    DSED_Display(6,6);
  27.      DSED_Display(7,7);
  28.      DSED_Display(8,8);
  30.         
  31.         
  32.     }    
  33.         
  34. }
  36. //函数定义区域
  37. void Delay(int ms)        //@11.0592MHz
  38. {
  39.     unsigned char i, j;
  40.     for(i = 0;i < ms;i++)
  41.     {
  42.         _nop_();
  43.     _nop_();
  44.     _nop_();
  45.     i = 11;
  46.     j = 190;
  47.     do
  48.     {
  49.         while (--j);
  50.     } while (--i);
  51.                 
  52.     }
  53.     
  54. }
  56. void DSED_Display(unsigned char dseg,unsigned char seg)
  57. {
  58.     P0 = 0XFF;//消影
  59.     P2=0XC0;P0=DSEG[dseg];//打开控制数码管位选的锁存器，然后选中第一个数码管
  60.     P2=0XFF;P0=SEG[seg];
  61.     Delay(1);
  62.     
  63.     
  64. }
②法二：
  1. #include <STC15F2K60S2.H>
  2. #include<intrins.h>
  4. unsigned char tab[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
  5. //unsigned char code tab[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
  7. unsigned char SEG1,SEG2,SEG3,SEG4,SEG5,SEG6,SEG7,SEG8;
  9. void Delay(int ms)；
  10. void SEG_Display(unsigned char yi,unsigned char er,unsigned char san,unsigned char si,unsigned char wu,unsigned char liu,unsigned char qi,unsigned char ba);
  12. void main(void)
  13. {
  14.     
  15.     P2=0XA0;P0=0X00;P2=0X80;P0=0XFF;        //初始化程序，后期详解;
  17.     
  18.     while(1)
  19.     {
  20.         SEG1=1,SEG2=2,SEG3=3,SEG4=4,SEG5=5,SEG6=6,SEG7=7,SEG8=8;
  21.         SEG_Display(SEG1,SEG2,SEG3,SEG4,SEG5,SEG6,SEG7,SEG8);
  22.     }
  23. }
  25. void SEG_Display(unsigned char yi,unsigned char er,unsigned char san,unsigned char si,unsigned char wu,unsigned char liu,unsigned char qi,unsigned char ba)
  26. {
  27.         P0=0XFF;
  28.         P2=0XC0;P0=0X01;     //打开控制数码管位选的锁存器，然后选中第一个数码管
  29.         P2=0XFF;P0=tab[yi];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  30.         Delay_MS(1);
  31.         
  32.         P0=0XFF;
  33.         P2=0XC0;P0=0X02;     //打开控制数码管位选的锁存器，然后选中第二个数码管
  34.         P2=0XFF;P0=tab[er];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  35.         Delay_MS(1);
  36.         
  37.         P0=0XFF;
  38.         P2=0XC0;P0=0X04;     //打开控制数码管位选的锁存器，然后选中第三个数码管
  39.         P2=0XFF;P0=tab[san];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  40.         Delay_MS(1);
  41.         
  42.         P0=0XFF;
  43.         P2=0XC0;P0=0X08;     //打开控制数码管位选的锁存器，然后选中第四个数码管
  44.         P2=0XFF;P0=tab[si];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  45.         Delay_MS(1);
  46.         
  47.         P0=0XFF;
  48.         P2=0XC0;P0=0X10;     //打开控制数码管位选的锁存器，然后选中第五个数码管
  49.         P2=0XFF;P0=tab[wu];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  50.         Delay_MS(1);
  51.         
  52.         P0=0XFF;
  53.         P2=0XC0;P0=0X20;     //打开控制数码管位选的锁存器，然后选中第六个数码管
  54.         P2=0XFF;P0=tab[liu];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  55.         Delay_MS(1);
  56.         
  57.         P0=0XFF;
  58.         P2=0XC0;P0=0X40;     //打开控制数码管位选的锁存器，然后选中第七个数码管
  59.         P2=0XFF;P0=tab[qi];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  60.         Delay_MS(1);
  61.         
  62.         P0=0XFF;
  63.         P2=0XC0;P0=0X80;     //打开控制数码管位选的锁存器，然后选中第八个数码管
  64.         P2=0XFF;P0=tab[ba];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  65.         Delay_MS(1);    
  66. }
  68. void Delay(int ms)        //@11.0592MHz
  69. {
  70.     unsigned char i, j;
  71.     for(i = 0;i < ms;i++)
  72.     {
  73.         _nop_();
  74.     _nop_();
  75.     _nop_();
  76.     i = 11;
  77.     j = 190;
  78.     do
  79.     {
  80.         while (--j);
  81.     } while (--i);
  82.                 
  83.     }
  84.     
  85. }
③法三
  1. #include <STC15F2K60S2.H>
  2. #include<intrins.h>
  4. //#define uchar unsigned char
  5. //#define uint unsigned int
  6.     
  7. typedef unsigned char uchar ;
  8. typedef unsigned int uint ;
  10. unsigned char tab[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
  11. //unsigned char code tab[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
  13. unsigned char SEG1,SEG2,SEG3,SEG4,SEG5,SEG6,SEG7,SEG8;
  15. void Delay(int ms);
  16. void SEG_Display12(uchar yi,uchar er);
  17. void SEG_Display34(uchar san,uchar si);
  18. void SEG_Display56(unsigned char wu,unsigned char liu);
  19. void SEG_Display78(unsigned char qi,unsigned char ba);
  21. void main(void)
  22. {
  24.     
  25.     P2=0XA0;P0=0X00;P2=0X80;P0=0XFF;        //初始化程序，后期详解;
  27.     while(1)
  28.     {
  29.         SEG1=1,SEG2=2,SEG3=3,SEG4=4,SEG5=5,SEG6=6,SEG7=7,SEG8=8;
  30.         
  31.         SEG_Display12(SEG1,SEG2);
  32.         SEG_Display34(SEG3,SEG4);
  33.         SEG_Display56(SEG5,SEG6);
  34.         SEG_Display78(SEG7,SEG8);
  35.     }
  36. }
  38. void SEG_Display12(unsigned char yi,unsigned char er)
  39. {
  40.         P0=0XFF;
  41.         P2=0XC0;P0=0X01;     //打开控制数码管位选的锁存器，然后选中第一个数码管
  42.         P2=0XFF;P0=tab[yi];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  43.         Delay_MS(1);
  44.         
  45.         P0=0XFF;
  46.         P2=0XC0;P0=0X02;     //打开控制数码管位选的锁存器，然后选中第二个数码管
  47.         P2=0XFF;P0=tab[er];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  48.         Delay_MS(1);    
  49. }
  51. void SEG_Display34(unsigned char san,unsigned char si)
  52. {
  53.         P0=0XFF;
  54.         P2=0XC0;P0=0X04;     //打开控制数码管位选的锁存器，然后选中第三个数码管
  55.         P2=0XFF;P0=tab[san];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  56.         Delay_MS(1);
  57.         
  58.         P0=0XFF;
  59.         P2=0XC0;P0=0X08;     //打开控制数码管位选的锁存器，然后选中第四个数码管
  60.         P2=0XFF;P0=tab[si];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  61.         Delay_MS(1);    
  62. }
  64. void SEG_Display56(unsigned char wu,unsigned char liu)
  65. {
  66.         P0=0XFF;
  67.         P2=0XC0;P0=0X10;     //打开控制数码管位选的锁存器，然后选中第五个数码管
  68.         P2=0XFF;P0=tab[wu];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  69.         Delay_MS(1);
  70.         
  71.         P0=0XFF;
  72.         P2=0XC0;P0=0X20;     //打开控制数码管位选的锁存器，然后选中第六个数码管
  73.         P2=0XFF;P0=tab[liu];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  74.         Delay_MS(1);
  75. }
  76. void SEG_Display78(unsigned char qi,unsigned char ba)
  77. {
  78.         P0=0XFF;
  79.         P2=0XC0;P0=0X40;     //打开控制数码管位选的锁存器，然后选中第七个数码管
  80.         P2=0XFF;P0=tab[qi];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  81.         Delay_MS(1);
  82.         
  83.         P0=0XFF;
  84.         P2=0XC0;P0=0X80;     //打开控制数码管位选的锁存器，然后选中第八个数码管
  85.         P2=0XFF;P0=tab[ba];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  86.         Delay_MS(1);        
  87. }
  89. void Delay(int ms)        //@11.0592MHz
  90. {
  91.     unsigned char i, j;
  92.     for(i = 0;i < ms;i++)
  93.     {
  94.         _nop_();
  95.     _nop_();
  96.     _nop_();
  97.     i = 11;
  98.     j = 190;
  99.     do
  100.     {
  101.         while (--j);
  102.     } while (--i);
  103.                 
  104.     }
  105.     
  106. }

（4）例程4：多位数码管倒计时。本例以第6、7、8位数码管显示255→0的倒计时为例，其他数码管保持熄灭。

  1. #include <STC15F2K60S2.H>
  2. #include<intrins.h>
  4. #define uchar unsigned char
  5. #define uint unsigned int
  7. unsigned char tab[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
  8. //unsigned char code tab[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF};
  10. unsigned char SEG1,SEG2,SEG3,SEG4,SEG5,SEG6,SEG7,SEG8;
  11. unsigned char Num = 255 ;
  12. unsigned char Num_Refresh = 0 ;
  14. void Delay(uint MS);
  15. void SEG_Display12(uchar yi,uchar er);
  16. void SEG_Display34(uchar san,uchar si);
  17. void SEG_Display56(unsigned char wu,unsigned char liu);
  18. void SEG_Display78(unsigned char qi,unsigned char ba);
  20. void main(void)
  21. {
  22.     
  23.     P2=0XA0;P0=0X00;P2=0X80;P0=0XFF;        //初始化程序，后期详解;
  24.     P2=0XC0;P0=0X01;P2=0XFF;P0=0XFF;        //打开第一个数码管，后期详解；
  25.     
  26.     SEG1=11,SEG2=11,SEG3=11,SEG4=11,SEG5=11;
  27.     SEG6=2,SEG7=5,SEG8=5;
  28.     while(1)
  29.     {        
  30.         
  31.       if(++Num_Refresh==125)
  32.         {
  33.             Num_Refresh = 0 ;
  34.             Num = Num -1; //Num--;
  35.             SEG6=Num/100,SEG7=Num%100/10,SEG8=Num%10;
  36.         }
  37.         
  38.         SEG_Display12(SEG1,SEG2);
  39.         SEG_Display34(SEG3,SEG4);
  40.         SEG_Display56(SEG5,SEG6);
  41.         SEG_Display78(SEG7,SEG8);
  42.     }
  43. }
  45. void SEG_Display12(unsigned char yi,unsigned char er)
  46. {
  47.         P0=0XFF;
  48.         P2=0XC0;P0=0X01;     //打开控制数码管位选的锁存器，然后选中第一个数码管
  49.         P2=0XFF;P0=tab[yi];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  50.         Delay_MS(1);
  51.         
  52.         P0=0XFF;
  53.         P2=0XC0;P0=0X02;     //打开控制数码管位选的锁存器，然后选中第二个数码管
  54.         P2=0XFF;P0=tab[er];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  55.         Delay_MS(1);    
  56. }
  58. void SEG_Display34(unsigned char san,unsigned char si)
  59. {
  60.         P0=0XFF;
  61.         P2=0XC0;P0=0X04;     //打开控制数码管位选的锁存器，然后选中第三个数码管
  62.         P2=0XFF;P0=tab[san];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  63.         Delay_MS(1);
  64.         
  65.         P0=0XFF;
  66.         P2=0XC0;P0=0X08;     //打开控制数码管位选的锁存器，然后选中第四个数码管
  67.         P2=0XFF;P0=tab[si];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  68.         Delay_MS(1);    
  69. }
  71. void SEG_Display56(unsigned char wu,unsigned char liu)
  72. {
  73.         P0=0XFF;
  74.         P2=0XC0;P0=0X10;     //打开控制数码管位选的锁存器，然后选中第五个数码管
  75.         P2=0XFF;P0=tab[wu];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  76.         Delay_MS(1);
  77.         
  78.         P0=0XFF;
  79.         P2=0XC0;P0=0X20;     //打开控制数码管位选的锁存器，然后选中第六个数码管
  80.         P2=0XFF;P0=tab[liu];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  81.         Delay_MS(1);
  82. }
  83. void SEG_Display78(unsigned char qi,unsigned char ba)
  84. {
  85.         P0=0XFF;
  86.         P2=0XC0;P0=0X40;     //打开控制数码管位选的锁存器，然后选中第七个数码管
  87.         P2=0XFF;P0=tab[qi];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  88.         Delay_MS(1);
  89.         
  90.         P0=0XFF;
  91.         P2=0XC0;P0=0X80;     //打开控制数码管位选的锁存器，然后选中第八个数码管
  92.         P2=0XFF;P0=tab[ba];    //打开控制数码管段选的锁存器，然后给上述打开的数码管输出码值
  93.         Delay_MS(1);        
  94. }
  96. void Delay(uint MS)    //@11.0592MHz
  97. {
  98.     unsigned char i, j;
  99.     for(i = 0;i < ms;i++)
  100.     {
  101.         _nop_();
  102.     _nop_();
  103.     _nop_();
  104.     i = 11;
  105.     j = 190;
  106.     do
  107.     {
  108.         while (--j);
  109.     } while (--i);
  110.                 
  111.     }
  112.
标签： 蓝桥杯 单片机 51单片机
本文转载自: https://blog.csdn.net/La_gloire/article/details/136304399
版权归原作者 La_gloire 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【蓝桥杯单片机入门记录】动态数码管”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。