设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 关于一个单片机电子钟 前一个贴发的有点逊 这个贴附程 ...
返回列表 发新帖
查看: 1515|回复: 1
打印 上一主题 下一主题
收起左侧

关于一个单片机电子钟 前一个贴发的有点逊 这个贴附程序和原理图

[复制链接]
跳转到指定楼层
楼主
ID:627013 发表于 2019-10-30 12:51 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
程序的目的是实现 八位数码管实时显示时分秒，循环显示周期为“00-00-00 至 23-59-59”。
按键1设置时加  按键2设置时减1  按键3进入设置模式  按键4切换闹钟和时钟显示界面   按键5设置时位选
  大部分内容已经实现   在我想加入T1做为定时检测闹钟与时钟数值并在闹钟与时钟数值相等时使得蜂鸣器响1分钟 但T1定时器中断无法正常运作。


单片机源程序如下:
  1. #include <reg51.h>
  2. #define uc unsigned char
  3. #define ui unsigned int
  4. uc code duan[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
  5. uc code weima[]={0xfe,0xfd,0xf7,0xef,0xbf,0x7f};
  6. int zancun1[6];
  7. int zancun2[6];
  8. uc second1=0,minute1=0,hour1=0,second2=0,minute2=0,hour2=0;     
  9. ui mode=0,set=0,setw=0,set1=0,setw1=0;
  10. sbit K1=P3^0;
  11. sbit K2=P3^1;
  12. sbit K3=P3^2;
  13. sbit K4=P3^3;
  14. sbit K5=P3^4;
  15. sbit P00=P0^0;
  16. void chu1(uc x,y,z,o,p,q)
  17. {
  18. zancun1[0]=x%10;
  19. zancun1[1]=x/10;
  20. zancun1[2]=y%10;
  21. zancun1[3]=y/10;
  22. zancun1[4]=z%10;
  23. zancun1[5]=z/10;
  24. zancun2[0]=o%10;
  25. zancun2[1]=o/10;
  26. zancun2[2]=p%10;
  27. zancun2[3]=p/10;
  28. zancun2[4]=q%10;
  29. zancun2[5]=q/10;
  30. }
  31. void save1()
  32. {
  33. second1=zancun1[1]*10+zancun1[0];
  34. minute1=zancun1[3]*10+zancun1[2];
  35. hour1=zancun1[5]*10+zancun1[4];
  36. }
  37. void save2()
  38. {
  39. second2=zancun2[1]*10+zancun2[0];
  40. minute2=zancun2[3]*10+zancun2[2];
  41. hour2=zancun2[5]*10+zancun2[4];
  42. }
  43. ui chouse(int a,int b)
  44. {
  45.     switch(a)
  46. {
  47.   case 0: if(b<=0||b>=10){b=0;}zancun1[0]=b;break;
  48.      case 1: if(b<=0||b>=6){b=0;}zancun1[1]=b;break;
  49.   case 2: if(b<=0||b>=10){b=0;}zancun1[2]=b;break;
  50.   case 3: if(b<=0||b>=6){b=0;}zancun1[3]=b;break;
  51.   case 4: if(b<=0||b>=5){b=0;}zancun1[4]=b;break;
  52.   case 5: if(b<=0||b>=3){b=0;}zancun1[5]=b;break;
  53. }
  54. return (set=b);
  55. }
  56. ui chouse2(int a,int b)
  57. {
  58.     switch(a)
  59. {
  60.   case 0: if(b<=0||b>=10){b=0;}zancun2[0]=b;break;
  61.      case 1: if(b<=0||b>=6){b=0;}zancun2[1]=b;break;
  62.   case 2: if(b<=0||b>=10){b=0;}zancun2[2]=b;break;
  63.   case 3: if(b<=0||b>=6){b=0;}zancun2[3]=b;break;
  64.   case 4: if(b<=0||b>=5){b=0;}zancun2[4]=b;break;
  65.   case 5: if(b<=0||b>=3){b=0;}zancun2[5]=b;break;
  66. }
  67. return (set1=b);
  68. }
  69. void delay(unsigned int y)
  70. {
  71. unsigned char j;
  72. unsigned int i;
  73. for(i=0;i<y;i++)
  74.   for(j=0;j<120;j++);
  75. }
  76. void shizhong(ui o,p,q)
  77. {
  78.   P1=weima[0];
  79.   P2=duan[o%10];
  80.   delay(8);   
  81.   P1=weima[1];
  82.   P2=duan[o/10];  
  83.   delay(8);   
  84.   P1=weima[2];
  85.   P2=duan[p%10];  
  86.   delay(8);  
  87.   P1=weima[3];   
  88.   P2=duan[p/10];   
  89.   delay(8);
  90.   P1=weima[4];      
  91.   P2=duan[q%10];  
  92.   delay(8);   
  93.   P1=weima[5];   
  94.   P2=duan[q/10];     
  95.   delay(8);
  96.   P1=0xdb;
  97.   P2=0x40;
  98.   delay(8);   
  99.   P1=0xff;
  100. }
  101. void time0s()
  102. {
  103. TMOD|=0X01;
  104. TH0=0X3c;
  105. TL0=0Xb0;
  106. ET0=1;
  107. TR0=1;
  108. PT0=1;
  109. PT1=0;  
  110. }
  111. void time1sON()
  112. {
  113.     TMOD|=0X10;
  114. TH1=0X3c;
  115. TL1=0Xb0;
  116. ET1=1;
  117. TR1=1;  
  118. }
  119. void Time0() interrupt 1
  120. {
  121. static ui i=0;
  122. TH0=0X3C;
  123. TL0=0Xb0;
  124. i++;
  125. if(i==20)
  126. {
  127.   i=0;
  128.   second1++;
  129.   if(second1==60)
  130.        {
  131.         second1=0;
  132.   minute1++;
  133.        }
  134.      if(minute1==60)
  135.     {
  136.      minute1=0;
  137.   hour1++;
  138.     }
  139.      if(hour1==24)
  140.     {
  141.      hour1=0;
  142.     }
  143. }
  144. }
  145. void Time1() interrupt 3
  146. {
  147. static ui i=0,r=0;
  148. TH1=0X3C;
  149. TL1=0Xb0;
  150. if(i==20)
  151. {
  152.   r++;
  153.   if(r==60)
  154.    {
  155.     if(minute1==minute2&&hour1==hour2)
  156.     {
  157.      for(r=0;r<10;r++)
  158.    {
  159.     P00=~P00;
  160.     delay(100);
  161.     r=0;
  162.    }
  163.     }
  164.     }
  165. }

  167. }
  168. void key()
  169. {   
  170.   EA=1;   
  171.      EX1=1;   
  172.      IT1=1;
  173.   EX0=1;
  174.   IT0=1;              
  175. }  
  176. void key3() interrupt 0
  177. {
  178.   EX1=0;
  179.   chu1(second1,minute1,hour1,second2,minute2,hour2);
  180.   while(1)
  181.   {
  182.    if(mode==0)
  183.     {
  184.   set=zancun1[setw];
  185.     P1=weima[setw];
  186.   P2=duan[set];
  187.   delay(400);
  188.   P1=0xff;
  189.   delay(400);
  190.   if(K1==0){delay(50);set++;chouse(setw,set);}   
  191.   if(K2==0){delay(50);set--;chouse(setw,set);}     
  192.   if(K5==0){delay(50);setw++;set=0;if(setw>=6){setw=0;}}      
  193.   if(K3==0){delay(50);save1();set=0;setw=0;break;}         
  194. }
  195. else
  196. {
  197.   set1=zancun2[setw1];
  198.   P1=weima[setw1];
  199.   P2=duan[set1];  
  200.   delay(400);
  201.   P1=0xff;
  202.   delay(400);
  203.   if(K1==0){delay(50);set1++;chouse2(setw1,set1);}   
  204.   if(K2==0){delay(50);set1--;chouse2(setw1,set1);}  
  205.      if(K5==0){delay(50);setw1++;set1=0;if(setw1>=6){setw1=0;}}      
  206.   if(K3==0){delay(50);save2();set1=0;setw1=0;break;}
  207.     }
  208.    }
  209. IE0=0;
  210. IE1=0;
  211. EX1=1;
  212. }
  213.    
  214. void key4() interrupt 2  
  215. {
  216.   mode=~mode;
  217.   IE1=0;
  218. }
  219. void main()
  220. {
  221. key();
  222. time0s();
  223. time1sON();  
  224. while(1)  
  225. {
  226.   if(mode==0)
  227.   {
  228.    shizhong(second1,minute1,hour1);
  229.      
  230.   }
  231.   if(mode!=0)
  232.   {
  233.    shizhong(second2,minute2,hour2);
  234.      }   
  235. }
  236. }
复制代码


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:155507 发表于 2019-10-30 19:09 | 只看该作者
程序分享出来给需要的人作参考

  1. //实验平台：TX-1C开发板（板子上是有源蜂鸣器，程序按无源编写的）
  2. //K1键调整选择,K2键+,长按连+，K3键-，长按连-，K4键闹钟设置
  3. //定时器初始化程序根据晶振频率选择
  4. //用计数法代替软件延时，提高走时精度
  5. //数码管采用分时动态显示，约2ms显示1位
  6. #include <reg51.h>
  7. #define uint unsigned int
  8. #define uchar unsigned char
  9. #define key_S 300                                        //宏定义短按(约20ms)
  10. #define key_L 6000                                        //宏定义长按(约2/3s)
  11. #define key_M 3000                                        //宏定义长按(约1/3s)
  12. sbit K1 = P3^4;                                                //调整选择/退出
  13. sbit K2 = P3^5;                                                //++，长按连+
  14. sbit K3 = P3^6;                                                //--，长按连-
  15. sbit K4 = P3^7;                                                //调整时间
  16. sbit dula=P2^6;                                                //段选
  17. sbit wela=P2^7;                                                //位选
  18. sbit allow=P2^5;                                                //LED使能
  19. sbit Buzzer=P2^3;                                                //蜂鸣器
  20. uchar code table[]={                                        //0~F数组
  21.         0x3f,0x06,0x5b,0x4f,
  22.         0x66,0x6d,0x7d,0x07,
  23.         0x7f,0x6f,0x77,0x7c,
  24.         0x39,0x5e,0x79,0x71};
  25. uint Cnt200us;                                                //定义200微秒变量
  26. uchar hour=12,min=0,sec=0;                        //定义时、分、秒变量
  27. uchar hour4=12,min4=0;                                //定义闹钟时、分变量
  28. uchar  Choice=0,Choice4=0;                        //调整走时的选择变量、设置闹钟的选择变量
  29. bit Buzzer_sign;                                        //蜂鸣器闹钟标志
  30. bit Twinkle,second=1;                                //闪烁标志、秒标志
  31. bit ban=0;                                                        //调闹禁止调时标志
  32. bit B_sign=0;
  33. /**************************************
  34.         定时器0/1初始化程序 @12.000MHz
  35. **************************************/
  36. /*
  37. void Timer0Init(void)
  38. {
  39.         TMOD= 0x22;                //设置定时器模式
  40.         TL0 = 0x38;                //设置定时初值200微秒
  41.         TH0 = 0x38;                //设置定时重载值200微秒
  42.         TR0 = 1;                //定时器0开始计时
  43.         EA=1;                        //开总中断
  44.         ET0=1;                        //开定时器0中断
  45. }
  46. */
  47. /***************************************
  48.         定时器0/1初始化程序 @11.0592MHz
  49. ***************************************/
  50. void Timer_Init()
  51. {
  52.         TMOD = 0x02;                                        //设置自动重载模式
  53.         TL0 = 0x48;                                                //设置定时初值200微秒
  54.         TH0 = 0x48;                                                //设置定时重载值200微秒
  55.         TR0 = 1;                                                //定时器0开始计时
  56.         EA=1;                                                        //开总中断
  57.         ET0=1;                                                        //开定时器0中断
  58. }

  60. /*************************
  61.           按键扫描程序
  62. *************************/
  63. void key_scan()
  64. {
  65.         static bit key1_sign,key4_sign;                        //按键自锁标志变量
  66.         static uint count1,count2,count3=0,count4=0;//消抖计数变量                       

  68.         if((!K1)&&(ban==0))                        //检测按键1按下与不在调闹禁止状态有效
  69.         {
  70.                 count1++;                                        //消抖计数1自+1
  71.                 if((count1>=key_S)&&(key1_sign==0))//检测消抖计数与按键1自锁标志
  72.                 {                       
  73.                         key1_sign=1;                        //按键1自锁标志置1
  74.                         Choice++;                                //调整选择变量自+1
  75.                         if(Choice>=4)                        //调整时间选择0正常走时，1调时，2调分，3调秒
  76.                         {
  77.                                 Choice=0;                        //调整时间选择清0
  78.                                 TF0=0;                                //定时器溢出标志TF0清0
  79.                                 Cnt200us=0;                        //时间变量Cnt200us自+1
  80.                         }
  81.                 }
  82.         }
  83.         else
  84.         {
  85.                 key1_sign=0;                                //按键1自锁标志清0
  86.                 count1=0;                                        //消抖计数count1清0
  87.         }
  88.                                
  89.         if(!K2)   
  90.         {  
  91.                 count2++;  
  92.                 if(count2>=key_L)                        //长按快调
  93.                 {
  94.                         if(Choice==1)                        //选择变量1调时
  95.                         {
  96.                                 hour++;
  97.                                 if(hour>=24)
  98.                                         hour=0;
  99.                         }
  100.                         if(Choice==2)                        //选择变量2调分
  101.                         {
  102.                                 min++;
  103.                                 if(min>=60)
  104.                                         min=0;
  105.                         }
  106.                         if(Choice==3)                        //选择变量3调秒
  107.                         {
  108.                                 sec++;
  109.                                 if(sec>=60)
  110.                                         sec=0;
  111.                         }
  112.                         if(Choice4==1)                        //选择变量1调时
  113.                         {
  114.                                 hour4++;
  115.                                 if(hour4>=24)
  116.                                         hour4=0;
  117.                         }
  118.                         if(Choice4==2)                        //选择变量2调分
  119.                         {
  120.                                 min4++;
  121.                                 if(min4>=60)
  122.                                         min4=0;
  123.                         }
  124.                         count2=key_M;
  125.                 }
  126.         }  
  127.         else                                                        //按键抬起
  128.         {  
  129.                 if(count2>key_S && count2<key_L)//短按
  130.                 {
  131.                         if(Choice==1)                        //选择变量1调时
  132.                         {
  133.                                 hour++;
  134.                                 if(hour>=24)
  135.                                         hour=0;
  136.                         }
  137.                         if(Choice==2)                        //选择变量2调分
  138.                         {
  139.                                 min++;
  140.                                 if(min>=60)
  141.                                         min=0;
  142.                         }
  143.                         if(Choice==3)                        //选择变量3调秒
  144.                         {
  145.                                 sec++;
  146.                                 if(sec>=60)
  147.                                         sec=0;
  148.                         }
  149.                         if(Choice4==1)                        //选择变量1调时
  150.                         {
  151.                                 hour4++;
  152.                                 if(hour4>=24)
  153.                                         hour4=0;
  154.                         }
  155.                         if(Choice4==2)                        //选择变量2调分
  156.                         {
  157.                                 min4++;
  158.                                 if(min4>=60)
  159.                                         min4=0;
  160.                         }
  161.                 }
  162.                 count2=0;                                        //count2清0
  163.         }   
  164.         if(!K3)   
  165.         {  
  166.                 count3++;  
  167.                 if(count3>=key_L)                        //长按
  168.                 {
  169.                         if(Choice==1)                        //选择变量
  170.                         {
  171.                                 hour--;
  172.                                 if(hour>=24)
  173.                                         hour=23;
  174.                         }
  175.                         if(Choice==2)                        //选择变量
  176.                         {
  177.                                 min--;
  178.                                 if(min>=60)
  179.                                         min=59;
  180.                         }
  181.                         if(Choice==3)                        //选择变量
  182.                         {
  183.                                 sec--;
  184.                                 if(sec>=60)
  185.                                         sec=59;
  186.                         }
  187.                         if(Choice4==1)                        //选择变量
  188.                         {
  189.                                 hour4--;
  190.                                 if(hour4>=24)
  191.                                         hour4=23;
  192.                         }
  193.                         if(Choice4==2)                        //选择变量
  194.                         {
  195.                                 min4--;
  196.                                 if(min4>=60)
  197.                                         min4=59;
  198.                         }
  199.                         count3=key_M;
  200.                 }
  201.         }  
  202.         else                                                        //按键抬起
  203.         {  
  204.                 if(count3>key_S && count3<key_L)//短按
  205.                 {
  206.                         if(Choice==1)                        //选择变量
  207.                         {
  208.                                 hour--;
  209.                                 if(hour>=24)
  210.                                         hour=23;
  211.                         }
  212.                         if(Choice==2)                        //选择变量
  213.                         {
  214.                                 min--;
  215.                                 if(min>=60)
  216.                                         min=59;
  217.                         }
  218.                         if(Choice==3)                        //选择变量
  219.                         {
  220.                                 sec--;
  221.                                 if(sec>=60)
  222.                                         sec=59;
  223.                         }
  224.                         if(Choice4==1)                        //选择变量
  225.                         {
  226.                                 hour4--;
  227.                                 if(hour4>=24)
  228.                                         hour4=23;
  229.                         }
  230.                         if(Choice4==2)                        //选择变量
  231.                         {
  232.                                 min4--;
  233.                                 if(min4>=60)
  234.                                         min4=59;
  235.                         }
  236.                 }
  237.                 count3=0;                                        //count3清0
  238.         }   
  239.         if((!K4)&&(Choice==0))                //检测按键4按下与不在调时状态有效
  240.         {
  241.                 count4++;                                        //消抖计数1自+1
  242.                 if((count4>=key_S)&&(key4_sign==0))//检测消抖计数与按键1自锁标志
  243.                 {                       
  244.                         key4_sign=1;                        //按键4自锁标志置1
  245.                         Choice4++;                                //调整选择变量自+1
  246.                         if(Choice4==1||Choice4==2)
  247.                                 ban=1;
  248.                         else ban=0;
  249.                         if(Choice4>=4)                        //调整闹钟时间选择0闹钟关闭，1调时，2调分，3开启闹钟
  250.                         {
  251.                                 Choice4=0;                        //调整时间选择清0
  252.                         }
  253.                 }
  254.         }
  255.         else
  256.         {
  257.                 key4_sign=0;                                //按键4自锁标志清0
  258.                 count4=0;                                        //消抖计数count1清0
  259.         }
  260. }
  261. /********************************
  262.                 数码管显示程序
  263. ********************************/
  264. void display()
  265. {
  266.         static uchar num=0;                                //分时显示变量
  267.         if((Choice4>0)&&(Choice4<3))//闹钟设置显示部分
  268.         {
  269.                 P0=0x00;        //消隐
  270.                 dula=1;
  271.                 dula=0;
  272.                 switch(num)
  273.                 {
  274.                         case 0:
  275.                                 P0=0x7e;                        //时十位位码
  276.                                 wela=1;
  277.                                 wela=0;
  278.                                 P0=table[hour4/10];        //时十位段码
  279.                                 dula=1;
  280.                                 dula=0;
  281.                                 num++;
  282.                          break;       
  283.        
  284.                         case 1:
  285.                                 P0=0x7d;                        //时个位位码
  286.                                 wela=1;
  287.                                 wela=0;
  288.                                 if((Twinkle==1)&&(Choice4==1))//时点闪烁
  289.                                         P0=table[hour4%10];
  290.                                 else
  291.                                         P0=table[hour4%10]|0x80;//时个位段码+点
  292.                                 dula=1;
  293.                                 dula=0;
  294.                                 num++;
  295.                          break;       
  296.        
  297.                         case 2:
  298.                                 P0=0x7b;                        //分十位位码
  299.                                 wela=1;
  300.                                 wela=0;
  301.                                 P0=table[min4/10];        //分十位段码
  302.                                 dula=1;
  303.                                 dula=0;
  304.                                 num++;
  305.                          break;       
  306.        
  307.                         case 3:
  308.                                 P0=0x77;                        //分个位位码
  309.                                 wela=1;
  310.                                 wela=0;
  311.                                 if((Twinkle==1)&&(Choice4==2))//分点闪烁
  312.                                         P0=table[min4%10];
  313.                                 else
  314.                                         P0=table[min4%10]|0x80;//分个位段码+点
  315.                                 dula=1;
  316.                                 dula=0;
  317.                                 num++;
  318.                          break;       

  320.                         case 4:
  321.                                 P0=0xef;                        //秒十位位码
  322.                                 wela=1;
  323.                                 wela=0;
  324.                                 P0=0x40;                        //秒十位段码
  325.                                 dula=1;
  326.                                 dula=0;
  327.                                 num++;
  328.                          break;       
  329.        
  330.                         case 5:
  331.                                 P0=0xdf;                        //秒个位位码
  332.                                 wela=1;
  333.                                 wela=0;
  334.                                 P0=0x40;                        //秒个位段码
  335.                                 dula=1;
  336.                                 dula=0;
  337.                                 num=0;
  338.                          break;       
  339.                 }
  340.         }
  341.         else        //正常走时和调整时间显示部分
  342.         {
  343.                 P0=0x00;        //消隐
  344.                 dula=1;
  345.                 dula=0;
  346.                 switch(num)
  347.                 {
  348.                         case 0:
  349.                                 P0=0x7e;                        //时十位位码
  350.                                 wela=1;
  351.                                 wela=0;
  352.                                 P0=table[hour/10];        //时十位段码
  353.                                 dula=1;
  354.                                 dula=0;
  355.                                 num++;
  356.                          break;       
  357.        
  358.                         case 1:
  359.                                 P0=0x7d;                        //时个位位码
  360.                                 wela=1;
  361.                                 wela=0;
  362.                                 if((Twinkle==1)&&(Choice==1))//时点闪烁
  363.                                         P0=table[hour%10];
  364.                                 else
  365.                                         P0=table[hour%10]|0x80;//时个位段码+点
  366.                                 dula=1;
  367.                                 dula=0;
  368.                                 num++;
  369.                          break;       
  370.        
  371.                         case 2:
  372.                                 P0=0x7b;                        //分十位位码
  373.                                 wela=1;
  374.                                 wela=0;
  375.                                 P0=table[min/10];        //分十位段码
  376.                                 dula=1;
  377.                                 dula=0;
  378.                                 num++;
  379.                          break;       
  380.        
  381.                         case 3:
  382.                                 P0=0x77;                        //分个位位码
  383.                                 wela=1;
  384.                                 wela=0;
  385.                                 if((Twinkle==1)&&(Choice==2))//分点闪烁
  386.                                         P0=table[min%10];
  387.                                 else
  388.                                         P0=table[min%10]|0x80;//分个位段码+点
  389.                                 dula=1;
  390.                                 dula=0;
  391.                                 num++;
  392.                          break;       
  393.        
  394.                         case 4:
  395.                                 P0=0xef;                        //秒十位位码
  396.                                 wela=1;
  397.                                 wela=0;
  398.                                 P0=table[sec/10];        //秒十位段码
  399.                                 dula=1;
  400.                                 dula=0;
  401.                                 num++;
  402.                          break;       
  403.        
  404.                         case 5:
  405.                                 P0=0xdf;                        //秒个位位码
  406.                                 wela=1;
  407.                                 wela=0;
  408.                                 if((Choice4==3)&&(Choice!=3))
  409.                                         P0=table[sec%10]|0x80;//闹钟启动后秒个位+点
  410.                                 else if((Twinkle==1)&&(Choice==3))//秒点闪烁+点
  411.                                         P0=table[sec%10]|0x80;
  412.                                 else
  413.                                         P0=table[sec%10];//秒个位段码
  414.                                 dula=1;
  415.                                 dula=0;
  416.                                 num=0;
  417.                          break;       
  418.                 }
  419.         }
  420. }
  421. /********************************
  422.                 闹钟程序
  423. ********************************/
  424. void Buzzer_nz()
  425. {
  426.         if((Choice4==3)&&(hour4==hour)&&(min4==min)&&(sec<30))
  427.                 Buzzer_sign=1;
  428.         else Buzzer_sign=0;
  429.         if((second==1)&&(Buzzer_sign==1))        //计时周期1s       
  430.         {
  431. //                TR1 = 1;                                        //定时器1开，蜂鸣器响一下
  432.                 B_sign=1;
  433.                 second=0;                                        //定时周期1s变量清0
  434.         }
  435. }
  436. /********************************
  437.                 主程序
  438. ********************************/
  439. void main(void)
  440. {
  441.         Timer_Init();                                        //初始化定时器
  442.         allow=0;                                                //关闭LED
  443.         while(1)
  444.         {
  445.                 if(sec>=60)                                        //如果秒>=60
  446.                 {
  447.                         sec=0;                                        //秒清0
  448.                         min++;                                        //分自+1
  449.                         if(min>=60)                                //分>=60
  450.                         {
  451.                                 min=0;                                //分清0
  452.                                 hour++;                          //小时自+1
  453.                                 if(hour>=24)                //小时>=24
  454.                                         hour=0;                        //小时清0
  455.                         }
  456.                 }
  457.                 key_scan();                                        //按键扫描
  458.                 display();                                        //显示
  459.                 Buzzer_nz();                                //闹钟
  460.         }
  461. }
  462. /*-----------------------------
  463.   定时器0中断服务程序  200微秒
  464. ------------------------------*/
  465. void timer0() interrupt        1
  466. {
  467.         static uint count3=0;
  468.         Cnt200us++;                                        //时间变量Cnt200us自+1
  469.         if((Cnt200us>1250 && Cnt200us<2500)||(Cnt200us>3750 && Cnt200us<5000))//闪烁频率2Hz               
  470.                 Twinkle=1;                                //闪烁标志
  471.         else Twinkle=0;
  472.         if(Cnt200us>=4991)                    //在此可以调整精度
  473.         {
  474.                 Cnt200us=0;                                //变量Cnt200us清0
  475.                 second=1;
  476.                 if(Choice!=3)                        //调整选择变量为3停止走秒
  477.                         sec++;                                //秒自+1
  478.         }
  479.         if(B_sign==1)
  480.         {
  481.                 Buzzer=~Buzzer;
  482.                 count3++;
  483.                 if(count3>=500)                                        //0.1秒时间到500
  484.                 {
  485.                         count3=0;                                        //计数清0                               
  486.                         Buzzer=1;                                        //蜂鸣器端口清0
  487.                         B_sign=0;                                        //蜂鸣器标志清0
  488.                 }
  489.         }
  490. }
  491. /*-----------------------------
  492.   定时器1中断服务程序  250微秒
  493.   (无源蜂鸣器驱动程序)
  494. ------------------------------*/
  495. /*
  496. void timer1() interrupt 3
  497. {
  498.         static uint count3=0;                        //中断计数变量
  499.         count3++;                                                //中断计数变量count3自+1
  500.         Buzzer=~Buzzer;                                        //蜂鸣器端口取反
  501.         if(count3>=500)                                        //0.1秒时间到500
  502.         {
  503.                 count3=0;                                        //计数清0                               
  504.                 Buzzer=1;                                        //蜂鸣器端口清0
  505.                 TR1 = 0;                                                //定时器1关闭
  506.         }
  507. }*/




复制代码
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表