51单片机

2051时针程序练手，全是自己写的，有仿真文件

2020-02-03 10:08发布

站内问答 / 51单片机
4665 2 2
本帖最后由 PRO 于 2012-10-17 15:48 编辑

之所以贴出来，一个也是因为这个电路并不像实验板那么整洁，大家看附件的仿真文件就清楚，另一方面也是之前学习的笔记吧
__.JPG (93.88 KB, 下载次数: 0) 下载附件 2012-10-17 15:47 上传
程序

  2. /*        本程序仅应用于‘4位单片机电子钟电路’
  3.         2051
  4.         晶振 3.579MHz
  5.                 main.c
  6. */
  7. #include <STC11.H>
  8. #define uint unsigned int
  9. #define uchar unsigned char
  10. uchar code table[]={0xfd,0x25,0xbb,0xaf,0x67,0xcf,0xdf,0xa5,0xff,0xef};         //0~9仅限本电路,正常显示
  11. uchar code table2[]={0xfc,0x24,0xba,0xae,0x66,0xce,0xde,0xa4,0xfe,0xee};
  12. uchar x,h,m,s,flag,ID,flag_set;                        //ID=1调整分钟 ID=2调整时钟
  13. void delay(uint a)                  //延时函数0~65535
  14. {                                          
  15.         while(a--);
  16. }

  18. void display()                                  //显示函数
  19. {       
  20.         uchar x=1000;                          //x延时时间
  21.        
  22.         if(flag_set!=1)
  23.         {
  24.                 P37=0;                                          //显示分个位
  25.                 P1=table[m%10];
  26.                 delay(x);
  27.                 P37=1;
  28.                
  29.                 P32=0;                                          //显示分十位
  30.                 P1=table[m/10];                                         
  31.                 delay(x);
  32.                 P32=1;
  33.   }
  34.         else
  35.         {
  36.                 if (flag)
  37.                 {
  38.                         P37=0;                                          //显示分个位
  39.                         P1=0x01;
  40.                         delay(x);
  41.                         P37=1;
  42.        
  43.                         P32=0;                                          //显示分十位
  44.                         P1=0x01;                                         
  45.                         delay(x);
  46.                         P32=1;
  47.                 }
  48.                 else
  49.                 {
  50.                         P37=0;                                          //显示分个位
  51.                         P1=table[m%10];
  52.                         delay(x);
  53.                         P37=1;
  54.                        
  55.                         P32=0;                                          //显示分十位
  56.                         P1=table[m/10];                                         
  57.                         delay(x);
  58.                         P32=1;
  59.                 }
  60.         }
  61.        
  62.         if(flag_set!=2)
  63.         {
  64.                 P31=0;                                          //显示时个位
  65.                 P1=table[h%10];
  66.                 delay(x);
  67.                 P31=1;
  68.        
  69.                 if (flag)                                 //闪烁秒和显示时十位
  70.                 {
  71.                         P30=0;                                          
  72.                   P1=table[h/10];
  73.                   delay(x);
  74.                   P30=1;
  75.                 }
  76.                 else
  77.                 {
  78.                   P30=0;                                          
  79.                   P1=table2[h/10];
  80.                   delay(x);
  81.                   P30=1;
  82.                 }
  83.         }
  84.         else
  85.         {
  86.                 if(flag)
  87.                 {
  88.                         P31=0;                                          //显示时个位
  89.                         P1=0x01;
  90.                         delay(x);
  91.                         P31=1;
  92.                
  93.                         P30=0;                                          
  94.                   P1=0x01;
  95.                   delay(x);
  96.                   P30=1;
  97.                 }
  98.                 else
  99.                 {
  100.                         P31=0;                                          //显示时个位
  101.                         P1=table[h%10];
  102.                         delay(x);
  103.                         P31=1;

  105.                         P30=0;                                          //显示时十位
  106.                   P1=table[h/10];
  107.                   delay(x);
  108.                   P30=1;
  109.                 }                
  110.         }                                          
  111. }

  113. void keyscan()                          
  114. { uchar x=1000;                                          //x消抖延时系数
  115.         delay(x);
  116.   if(P34==0)
  117.         { while(P34==0)
  118.                                         display();
  119.                 ID++;
  120.           switch(ID)
  121.           {
  122.                    case 1:                                                                                 //set m        flag_set=1
  123.                                 flag_set=1;                                                         
  124.                                 while(P34)
  125.                                 {if(P35==0)
  126.                                   {        while(P35==0)
  127.                                                                         display();
  128.                                                 m++;
  129.                                                 if(m==60)
  130.                                                         m=0;         
  131.                                   }
  132.                                   else
  133.                                   {       
  134.                                                 display();
  135.                                         }
  136.                                 }       
  137.                                 break;

  139.                 case 2:                                                                                                 //set h    flag_set=2
  140.                         flag_set=2;                                                                         
  141.                   while(P34)
  142.                                 {if(P35==0)
  143.                                   {        while(P35==0)
  144.                                                                         display();
  145.                                                 h++;
  146.                                                 if(h==24)
  147.                                                         h=0;         
  148.                                   }
  149.                                   else
  150.                                   {       
  151.                                                 display();
  152.                                         }
  153.                                 }       
  154.                                 break;

  156.                 case 3:
  157.                 ID=0;
  158.                 flag_set=0;
  159.                 break;
  160.           }
  161.                
  162.         }
  163.        
  164. }

  166. void main(void)
  167. {
  168.         TH0=(65536-29825)/256;          //中断初始化,100ms
  169.         TL0=(65536-29825)%256;       
  170.         TMOD=0x01;                                //定时器0方式1
  171.         ET0=1;                                          //中断T0允许
  172.         TR0=1;                                          //开T0
  173.         //EX0=1;                                        //开外部中断0
  174.         //IT0=1;                                        //下降沿触发
  175.         EA=1;                                                  //开总中断         

  177.         while(1)
  178.         {       
  179.           display();
  180.                 if (P34==0)
  181.                         keyscan();       
  182.         }
  183. }

  185. void t0() interrupt 1
  186. {        x++;
  187.         if(x%5==0)                                  //闪烁标志
  188.                  flag=~flag;
  189.         if(x==10)                                          //定时1s
  190.         { x=0;
  191.           s++;
  192.           if(s==60)
  193.           {        s=0;
  194.                         m++;
  195.                         if(m==60)
  196.                         {        m=0;
  197.                                 h++;
  198.                                 if(h==24)
  199.                                 {        h=0;        }
  200.                   }
  201.                 }       
  202.   }
  203.         TH0=(65536-29825)/256;                  //晶振3.579MHz，定时4ms减1193；定时100ms减29825；定时200ms减59650
  204.         TL0=(65536-29825)%256;       
  205. }


复制代码 四位单片机电子钟.zip (18.33 KB, 下载次数: 6) 2012-10-17 15:10 上传 点击文件名下载附件      仿真文件

友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
1条回答
lee345
1楼-- · 2020-02-03 11:00
帮忙顶下，对初学者有好处的

一周热门 更多>