标题: 单片机驱动8位数码管怎么让其中2位闪烁,求助大佬 [打印本页]
作者: 千年约定    时间: 2021-2-15 20:29
标题: 单片机驱动8位数码管怎么让其中2位闪烁,求助大佬
现在情况是只能整体闪烁不知道怎么控制其中2位闪烁
代码如下
  1. #include  "reg52.h"
  2. sbit  a=P2^2;
  3. sbit  b=P2^3;
  4. sbit  c=P2^4;
  5. sbit  k1=P3^0;
  6. sbit  k2=P3^1;
  7. sbit  k4=P3^3;
  8. sbit  k8=P3^7;

  10.    unsigned  char  i=0;
  11.    unsigned  int   l=0;
  12.    unsigned   int  flag=0;
  13.    unsigned   int  cishu=1;
  14.    unsigned    ssec=0,sec=5,min=0;
  15.    unsigned   DisplayData[8];
  16.    unsigned code  dongtai[17]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
  17.                                0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};
  18.      void  delay(unsigned  int  i)
  19.      {
  20.         while(i--);
  21.      }

  23.             void Timer0Init()
  24.           {
  25.             
  26.                          TMOD|=0X01;//选择为定时器0模式，工作方式1，仅用TR0打开启动。
  27.             TH0=0Xd8;        //给定时器赋初值，定时10ms
  28.                 TL0=0Xf0;        
  29.                 ET0=1;//打开定时器0中断允许
  30.                 EA=1;//打开总中断
  31.                 TR0=1;//打开定时器                        
  32.           }

  34.                      void Timer1Init()
  35.             {
  36.                     TMOD|=0X10;//选择为定时器1模式，工作方式1，仅用TR1打开启动。
  37.                     TH1=0XFC;        //给定时器赋初值，定时1ms
  38.                     TL1=0X18;        
  39.                     ET1=1;//打开定时器1中断允许
  40.                     EA=1;//打开总中断
  41.                     TR1=1;//打开定时器                        
  42.             }

  44.   void  aaa()
  45. {

  47.         DisplayData[4]=dongtai[min/10];
  48.         DisplayData[5]=dongtai[min%10]+0x80;
  49.         DisplayData[6]=dongtai[sec/10];
  50.         DisplayData[7]=dongtai[sec%10];

  52.          
  53.             DisplayData[0]=dongtai[cishu];        
  54.             DisplayData[1]=0x80;
  55.             DisplayData[2]=0x80;
  56.             DisplayData[3]=0x80;
  57.          
  58.          
  59.            if(min==0&&sec==0)
  60.             {
  61.                    DisplayData[4]= 0x3f;
  62.                    DisplayData[5]= 0x3f+0x80;
  63.                    DisplayData[6]= 0x3f;
  64.                    DisplayData[7]= 0x3f;
  65.             }
  66. }
  67.   void  abc()
  68. {
  69.         for(i=0;i<8;i++)
  70.         { switch(i)
  71.           { case(0): a=0;b=0;c=0; break;
  72.             case(1): a=1;b=0;c=0; break;
  73.             case(2): a=0;b=1;c=0; break;
  74.                 case(3): a=1;b=1;c=0; break;
  75.                 case(4): a=0;b=0;c=1; break;
  76.                 case(5): a=1;b=0;c=1; break;
  77.                 case(6): a=0;b=1;c=1; break;
  78.                 case(7): a=1;b=1;c=1; break;
  79.           }
  80.            if(l==1&&(i==0||i==1))
  81.            {
  82.                   Timer1Init();
  83.                            
  84.            }            
  85.           P0=DisplayData[i];
  86.                   
  87.                 delay(100);  
  88.                 P0=0x00;
  89.         
  90.     }                 
  91. }
  92.   void  main()
  93. {
  94.              P0=0x00;
  95.          while(1)
  96.        {  
  97.                    if(k1!=0xFF)
  98.                    delay(1000);
  99.                    if(k1!=0xFF)
  100.                   {                        
  101.                       flag++;
  102.                       if(flag==1)
  103.                         {
  104.                                        
  105.                     }
  106.                    else  if(flag>1)
  107.                   {
  108.                           flag=1;
  109.                           cishu++;
  110.                           if(cishu>=9)
  111.                         {
  112.                             cishu=1;
  113.                     }
  114.                   }
  115.                           Timer0Init();
  116.                                  sec=5;
  117.                             min=0;
  118.                  }  
  119.                  while(!k1);
  120.                              
  121.                   
  122.                    if(k2!=0xFF)
  123.                    delay(30000);
  124.                    if(k2!=0xFF)
  125.                   {                 
  126.                          l++;
  127.                          while(!k2);
  128.                           if(l>=5)
  129.                           {
  130.                            l=0;
  131.                           }
  132.                   }
  133.                   
  134.                   
  135.                   abc();        
  136.                   aaa();
  137.            }                                 
  138. }         

  140.    void Timer0() interrupt 1
  141. {
  142.         TH0=0Xd8;        //给定时器赋初值，定时10ms
  143.         TL0=0Xf0;
  144.         
  145.         ssec++;
  146.         if(ssec>=100)  //1s
  147.         {
  148.           ssec=0;
  149.           sec--;        
  150.           if(sec<=0)
  151.          {
  152.             if(min>0)
  153.            {
  154.                  sec=60;
  155.              min--;
  156.            }
  157.                 if(min<=0)
  158.            {         
  159.                    if(sec==0)
  160.                   {
  161.                       TR0=0;
  162.                   }
  163.            }
  164.          }
  165.         }
  166. }

  168.   void Timer1() interrupt 3
  169. {
  170.         static unsigned  int  j=0;
  171.         TH1=0XFC;        //给定时器赋初值，定时1ms
  172.         TL1=0X18;         
  173.         j++;  
  174.         if(j>=500)         
  175.         {
  176.                 j=0;
  177.           P0=0x00;
  178.           delay(20000);
  179.                   
  180.         }        
  181. }   
复制代码
   

作者: xianfajushi    时间: 2021-2-16 07:50
可参https://blog.csdn.net/xianfajushi/article/details/94927172
作者: 千年约定    时间: 2021-2-16 20:12
xianfajushi 发表于 2021-2-16 07:50
可参https://blog.csdn.net/xianfajushi/article/details/94927172

多谢大佬我去看看
作者: 千年约定    时间: 2021-2-16 20:49
xianfajushi 发表于 2021-2-16 07:50
可参https://blog.csdn.net/xianfajushi/article/details/94927172

sbit duan = P2^6;//数码段
sbit wei = P2^7;//数码位

不太明白为什么一个引脚就能控制数码管的位和段显示
我写的是8位数码管呀
真想不明白
作者: wulin    时间: 2021-2-16 22:23
你这程序写得问题不少，难以达到预期效果，给你改了，仿真正常。


  1. #include  "reg52.h"
  2. //sbit  a=P2^2;
  3. //sbit  b=P2^3;
  4. //sbit  c=P2^4;
  5. sbit  k1=P3^0;
  6. sbit  k2=P3^1;
  7. sbit  k4=P3^3;
  8. //sbit  k8=P3^7;

  10. unsigned char num,cishu=0;
  11. //unsigned int   l=0;
  12. bit flag=0;
  13. unsigned int ssec=0;
  14. char sec=0,min=0;
  15. bit sign=0;
  16. bit flash;
  17. unsigned char DisplayData[8];
  18. unsigned char code dongtai[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,
  19.                                                                 0x7f,0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71};

  21. void  delay(unsigned int i)
  22. {
  23.         while(i--);
  24. }

  26. void Timer0Init()
  27. {
  28.         TMOD|=0X01;//选择为定时器0模式，工作方式1，仅用TR0打开启动。      
  29.         TH0 = 0xFC;                //设置定时初值定时1ms
  30.         TL0 = 0x18;                //设置定时初值
  31.         ET0=1;//打开定时器0中断允许
  32.         EA=1;//打开总中断
  33.         TR0=1;//打开定时器                        
  34. }
  35. /*
  36. void Timer1Init()
  37. {
  38.         TMOD|=0X10;//选择为定时器1模式，工作方式1，仅用TR1打开启动。
  39.         TH1=0XFC;        //给定时器赋初值，定时1ms
  40.         TL1=0X18;        
  41.         ET1=1;//打开定时器1中断允许
  42.         EA=1;//打开总中断
  43.         TR1=1;//打开定时器                        
  44. }*/

  46. void  aaa()
  47. {
  48.         DisplayData[0]=dongtai[cishu];        
  49.         DisplayData[1]=0x40;
  50.         DisplayData[2]=0x40;
  51.         DisplayData[3]=0x40;
  52.         if(cishu==0)
  53.         {
  54.                 DisplayData[4]=dongtai[min/10];
  55.                 DisplayData[5]=dongtai[min%10]+0x80;
  56.                 DisplayData[6]=dongtai[sec/10];
  57.                 DisplayData[7]=dongtai[sec%10];
  58.         }
  59.         else
  60.         {
  61.                 if(cishu==1&&flash==1)
  62.                         DisplayData[4]=0;
  63.                 else
  64.                         DisplayData[4]=dongtai[min/10];
  65.                 if(cishu==2&&flash==1)
  66.                         DisplayData[5]=0x80;
  67.                 else
  68.                         DisplayData[5]=dongtai[min%10]+0x80;
  69.                 if(cishu==3&&flash==1)
  70.                         DisplayData[6]=0;
  71.                 else
  72.                         DisplayData[6]=dongtai[sec/10];
  73.                 if(cishu==4&&flash==1)
  74.                         DisplayData[7]=0;
  75.                 else
  76.                         DisplayData[7]=dongtai[sec%10];
  77.         }
  78.    /*
  79.         if(min==0&&sec==0)
  80.         {
  81.                 DisplayData[4]= 0x3f;
  82.                 DisplayData[5]= 0x3f+0x80;
  83.                 DisplayData[6]= 0x3f;
  84.                 DisplayData[7]= 0x3f;
  85.         }*/
  86. }

  88. void abc()
  89. {   
  90.         static unsigned char t=0;
  91.         P0=0x00;
  92.         P2&=0xe3;
  93.         P2|=(t<<2);
  94.         P0=DisplayData[t];
  95.         t=++t%8;
  96. }

  98. void  main()
  99. {
  100. //        P0=0x00;
  101.         Timer0Init();
  102.         while(1)
  103.         {  
  104.                 if(!k1||!k2||!k4)
  105.                 {
  106.                         delay(1000);
  107.                         if((!k1||!k2||!k4) && sign==0)
  108.                         {         
  109.                                 sign=1;
  110.                                 if(!k1 && flag==0)
  111.                                         cishu=++cishu%5;
  112.                                 if(!k2 && cishu>0)
  113.                                 {
  114.                                         switch(cishu)
  115.                                         {
  116.                                                 case 1: min+=10;if(min/10>5)min%=10; break;
  117.                                                 case 2: min++;if(min%10==0)min-=10; break;
  118.                                                 case 3: sec+=10;if(sec/10>5)sec%=10; break;
  119.                                                 case 4: sec++;if(sec%10==0)sec-=10; break;
  120.                                         }
  121.                                 }
  122.                                 if(!k4 && cishu==0)
  123.                                         flag=1;
  124.                         }
  125.                 }
  126.                 else sign=0;   
  127.                 aaa();
  128.         }
  129. }         

  131. void Timer0() interrupt 1
  132. {
  133.         TH0 = 0xFC;                //设置定时初值
  134.         TL0 = 0x18;                //设置定时初值
  135.         if(flag)
  136.         {
  137.                 if(min|sec!=0)
  138.                 {
  139.                         ssec++;
  140.                         if(ssec>=1000)  //1s
  141.                         {
  142.                                 ssec=0;
  143.                                 sec--;        
  144.                                 if(min==0&&sec==0)
  145.                                         flag=0;                       
  146.                                 else if(sec<0)
  147.                                 {
  148.                                         min--;
  149.                                         sec=59;
  150.                                 }
  151.                         }
  152.                 }
  153.                 else flag=0;
  154.         }
  155.         if(++num==200)
  156.         {
  157.                 num=0;
  158.                 flash=~flash;
  159.         }
  160.         abc();
  161. }
  162. /*
  163. void Timer1() interrupt 3
  164. {
  165.         static unsigned  int  j=0;
  166.         TH1=0XFC;        //给定时器赋初值，定时1ms
  167.         TL1=0X18;         
  168.         j++;  
  169.         if(j>=500)         
  170.         {
  171.                 j=0;
  172.                 P0=0x00;
  173.                 delay(20000);
  174.         }        
  175. }*/   
复制代码



作者: 千年约定    时间: 2021-2-17 11:14
本帖最后由 千年约定 于 2021-2-17 20:29 编辑
wulin 发表于 2021-2-16 22:23
你这程序写得问题不少，难以达到预期效果，给你改了，仿真正常。

大佬很感谢您认真看了我的程序并且花了很多时间进行了修改
很抱歉没在问题上说清楚我的程序具体功能。功能是数码管前两位用来计数倒计时的次数的，最后四位用来做倒计时的时钟，当我按K1按键的时候开始倒计时，当我长按K2按键的时候能够修改次数，分钟，秒钟，修改的时候对应的数码管能够闪烁显示，其他数码管正常显示，K4和K8用来对其加减

将您的程序略作修改后终于实现了2位闪烁功能
非常感谢
作者: wulin    时间: 2021-2-17 20:45
一位或多位数码管闪烁原理时一样的，按你的意图修改并详细注释，应该可以看得懂。
1秒至99分59秒倒计时程序数码管闪烁示例 仿真.zip (124.42 KB, 下载次数: 9)

作者: 千年约定    时间: 2021-2-17 23:06
wulin 发表于 2021-2-17 20:45
一位或多位数码管闪烁原理时一样的，按你的意图修改并详细注释，应该可以看得懂。

多谢大佬我去好好看看
作者: 两仪式    时间: 2021-2-18 00:29
为什么一个位和段能控制显示，因为一个单纯的七段数码管就要七个引脚去控制，如果8位的话，就需要56个脚，所以通过位选来选择哪一位显示，节省引脚。因此只能显示一位，但是它显示的很快，肉眼是看不出来的，也就等同于都亮了，你要亮哪个，选哪个就好了。


不用过多纠结，都是电路来的。
作者: 千年约定    时间: 2021-2-18 09:49
两仪式 发表于 2021-2-18 00:29
为什么一个位和段能控制显示，因为一个单纯的七段数码管就要七个引脚去控制，如果8位的话，就需要56个脚， ...

多谢大佬解释
作者: 12334345    时间: 2021-2-19 09:14
给高低电平并延时
作者: tyrl800    时间: 2021-2-20 15:24
楼主问题解决了吗？
作者: 千年约定    时间: 2021-3-1 11:47
tyrl800 发表于 2021-2-20 15:24
楼主问题解决了吗？

解决了




欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1