标题: 单片机秒表+功能键 仿真+源程序 [打印本页]
作者: YONG8421    时间: 2016-6-29 20:57
标题: 单片机秒表+功能键 仿真+源程序
仅供参考

源程序：



  4. ////////////////////////////////////////////////////////////////////////
  5. #include<reg51.h>                                                                                                          //
  6. #define led P2                                                                                                                  //
  7. #define wei P3                                                                                                                  //
  8. #define  ulongint unsigned long int                                                                          //
  9. #define  uint unsigned int                                                                                          //
  10. sbit k1=P1^0;                                                                                                                  //
  11. sbit k2=P1^1;                                                                                                                  //
  12. sbit k3=P1^2;                                                                                                                  //
  13. sbit k4=P1^3;                                                                                                                  //
  14. sbit k5=P1^4;                                                                                                                  //
  15. sbit led1=P3^7;                                                                                                                  //
  16.                                                                                                                                           //
  17. void delay(uint y);                                                                                                          //
  18. ulongint shi,s,mm,nn;                                                                                                  //
  19. ulongint num,tt;                                                                                                          //
  20. ulongint shu[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; //
  21.                                                                                                                                           //
  22. void xianshi()                                        ////////*显示函数*//////////                  //
  23. {                                                                                                                                          //
  24.         ulongint ge,bai,qian,wan,shiwan,baiwan,qianwan;                                          //
  25.         ge=  (num%10);                            /////////*显示个位*/////////                  //
  26.         shi=(num/10)%10;                        /////////        *           /////////                  //
  27.         bai=(num/100)%10;                        /////////        *           /////////                  //
  28.         qian=(num/1000)%10;                        /////////        *           /////////                  //
  29.         wan= (num/10000)%10;                /////////        *           /////////                  //
  30.         shiwan=(num/100000)%10;                /////////        *           /////////                  //
  31.         baiwan=(num/1000000)%10;    /////////        ×           /////////                  //
  32.         qianwan=(num/10000000)%10;        ///////*显示千万位*/////////                  //
  33. ////////////////////////////////////////////////////////////////////////                                                                                                                                         
  34.         wei=0xfe;             //                                                                                            //
  35.         led=shu[ge];     //                                                                                                  //
  36.         delay(5);             //                                                                                                  //
  37.                                      //                                                                                                  //
  38.                                      //                                                                                                  //
  39.         wei=0xfd;                 //                                                                                                  //
  40.         led=shu[shi];         //                                                                                                  //
  41.         delay(5);                 //                                                                                                  //
  42.                                          //                                                                                                  //
  43.                                          //                                                                                                  //
  44.         wei=0xfb;                 //                                                                                                  //
  45.         led=shu[bai];         //                                                                                                  //
  46.         delay(5);                 //                                                                                                  //
  47.                                          //                                                                                                  //
  48.                                          //                                                                                                  //
  49.         wei=0xf7;                 //                                                                                                  //
  50.         led=shu[qian];          //                                                                                                  //
  51.         delay(5);                 //                                                                                                  //
  52. ////////////////////////////////////////////////////////////////////////                                                                                  
  53.         wei=0xef;                 //                                                                                                  //
  54.         led=shu[wan];         //                                                                                                  //
  55.         delay(5);                 //                                                                                                  //
  56.                                          //                                                                                                  //
  57.                                          //                                                                                                  //
  58.         wei=0xdf;                 //                                                                                                  //
  59.         led=shu[shiwan]; //                                                                                                  //
  60.         delay(5);                 //                                                                                                  //
  61.                                          //                                                                                                  //
  62.                                          //                                                                                                  //
  63.         wei=0xbf;                  //                                                                                                  //
  64.         led=shu[baiwan]; //                                                                                                  //
  65.         delay(5);                 //                                                                                                  //
  66.                                          //                                                                                                  //
  67.                                           //                                                                                                  //
  68.         wei=0x7f;                 //                                                                                                  //
  69.         led=shu[qianwan];//                                                                                                  //
  70.         delay(5);                 //                                                                                                  //
  71.                                          //                                                                                                  //
  72. }                                         //                                                                                                  //
  73.                                          //                                                                                                  //
  74. //////////////////////////////延时函数//////////////////////////////////                                                                  
  75. void delay(uint y)                                                                                                          //
  76. {                                                                                                                                          //
  77.         uint j,k;                                                                                                                  //
  78.         for(j=0;j<y;j++)                                                                                                  //
  79.         for(k=0;k<100;k++);                                                                                                  //
  80. }                                                                                                                                          //
  81. ////////////////////////////////////////////////////////////////////////                                                                                                       
  82.                                                                                                                                           //
  83. void dingshi()                                  /////////*定时器中断函数*/////////          //
  84. {                                                                                                                                          //
  85.         TMOD=0X01;                                  /////////*定时器0工作方式0*/////////          //
  86.         TH0=(65536-50000)/256;          /////////*计算初值*/////////                           //
  87.         TL0=(65536-50000)/256;          /////////*计算初值*/////////                          //
  88.         EA=1;                                          /////////*打开中断总开关*/////////          //
  89.         ET0=1;                                          /////////*允许定时器启动*/////////          //
  90.         TR0=0;                                          /////////*启动定时器*/////////                  //
  91. }                                                                                                                                          //
  92.                                                                                                                                           //
  93. ////////////////////////////////////////////////////////////////////////
  94. void time0() interrupt 1          /////////*中断服务程序*/////////                  //
  95. {                                                                                                                                          //
  96.         TH0=(65536-50000)/256;                                                                                          //
  97.         TL0=(65536-50000)/256;                                                                                          //
  98.         tt = tt+1;                                                                                                                    //
  99.         mm++;                                                                                                                          //
  100.         nn++;                                                                                                                          //
  101.         if(tt == 2)                                  /////////*t=2时，t清零*/////////                  //
  102.         {                                                                                                                                    //
  103.         tt = 0;                                          //                **t清零**                        //                  //
  104.         num++;                                          /////////*t=2时，num+1*/////////                  //
  105.         }                                                                                                                                  //
  106. }                                                                                                                                          //
  107. ////////////////////////////////////////////////////////////////////////
  108. void key()                                           /////////*按键函数*/////////                          //
  109. {                                                                                                                                          //
  110.         if(k1==0)                                   /////////*k=0时，启动定时器*/////////  //
  111.         {                                                                                                                                  //
  112.         while(!k1);                                                                                                                  //
  113.         TR0=~TR0;                                                                                                                  //
  114.         s=0;                                           /////////*位选变量清零*/////////                  //
  115.         }                                                                                                                                  //
  116.         if(k2==0)                                   /////////*k=2时，数码管清零*/////////  //
  117.         {                                                                                                                                  //
  118.         while(!k2);                                                                                                                  //
  119.         num=0;                                                                                                                          //
  120.         s=0;                                                /////////*位选变量清零*/////////          //
  121.         }                                                                                                                                  //
  122.                                                                                                                                           //
  123. ////////////////////////////////////////////////////////////////////////
  124. //////////////////////////////led闪烁///////////////////////////////////
  125. if(mm==200)                                                                                                                          //
  126. {                                                                                                                                          //
  127.         led1=0;                                                                                                                          //
  128.         mm=0;                                                                                                                          //
  129. }                                                                                                                                          //
  130.                                                                                                                                           //
  131. if(nn==400)                                                                                                                          //
  132. {                                                                                                                                          //
  133.                                                                                                                                           //
  134.         led1=1;                                                                                                                          //
  135.         nn=0;                                                                                                                          //
  136. }                                                                                                                                          //
  137. ////////////////////////////////////////////////////////////////////////
  138. if(k3==0)                                        /////////*按键+1功能*/////////                          //
  139.   {                                                                                                                                          //
  140.          while(!k3);                                                                                                          //
  141.                 if(s==1)                                                                                                          //
  142.                 {                                                                                                                          //
  143.                 num++;                                         /////////*个位+1*/////////                          //
  144.                 }                                                                                                                          //
  145.                                                                                                                                           //
  146.                 if(s==2)                                                                                                          //
  147.                 {                                                                                                                          //
  148.                 num=num+10;                                 /////////*十位+1*/////////                          //
  149.                 }                                                                                                                          //
  150.                                                                                                                                           //
  151.                 if(s==3)                                                                                                          //
  152.                 {                                                                                                                          //
  153.                 num=num+100;                         /////////*百位+1*/////////                          //
  154.                 }                                                                                                                          //
  155.                                                                                                                                           //
  156.                 if(s==4)                                                                                                          //
  157.                 {                                                                                                                          //
  158.                 num=num+1000;                         /////////*千位+1*/////////                          //
  159.                 }                                                                                                                          //
  160.                                                                                                                                           //
  161.                 if(s==5)                                                                                                          //
  162.                 {                                                                                                                          //
  163.                 num=num+10000;                       /////////*万位+1*/////////                          //
  164.                 }                                                                                                                          //
  165.                                                                                                                                           //
  166.                 if(s==6)                                                                                                          //
  167.                 {                                                                                                                          //
  168.                 num=num+100000;                            /////////*十万位+1*/////////                  //
  169.                 }                                                                                                                          //
  170.                                                                                                                                           //
  171.                 if(s==7)                                                                                                          //
  172.                 {                                                                                                                          //
  173.                 s=0;                                           /////////*s清零*/////////                          //
  174.                 }                                                                                                                          //
  175.   }                                                                                                                                          //
  176.                                                                                                                                           //
  177.                                                                                                                                           //
  178.   if(k4==0)                                                                                                                          //
  179.   {                                                                                                                                          //
  180.          while(!k4);                                                                                                          //
  181.                 if(s==1)                                                                                                          //
  182.                 {                                                                                                                          //
  183.                 num--;                                        /////////*个位-1*/////////                          //
  184.                 }                                                                                                                          //
  185.                                                                                                                                           //
  186.                 if(s==2)                                                                                                          //
  187.                 {                                                                                                                          //
  188.                 num=num-10;                                /////////*十位-1*/////////                          //
  189.                 }                                                                                                                          //
  190.                                                                                                                                           //
  191.                 if(s==3)                                                                                                          //
  192.                 {                                                                                                                          //
  193.                 num=num-100;                        /////////*百位-1*/////////                          //
  194.                 }                                                                                                                          //
  195.                                                                                                                                           //
  196.                 if(s==4)                                                                                                          //
  197.                 {                                                                                                                          //
  198.                 num=num-1000;                        /////////*千位-1*/////////                          //
  199.                 }                                                                                                                          //
  200.                                                                                                                                           //
  201.                 if(s==5)                                                                                                          //
  202.                 {                                                                                                                          //
  203.                 num=num-10000;                        /////////*万位-1*/////////                          //
  204.                 }                                                                                                                          //
  205.                                                                                                                                           //
  206.                 if(s==6)                                                                                                          //
  207.                 {                                                                                                                          //
  208.                 num=num-100000;                        /////////*十万位-1*/////////                  //
  209.                 }                                                                                                                          //
  210.                 }                                                                                                                          //
  211. ///////////////////////////功能键（位选）///////////////////////////////
  212.         if(k5==0)                                                                                                                  //
  213.         {                                                                                                                                  //
  214.         while(!k5);                                                                                                                  //
  215.         s++;                                                                                                                          //
  216.         if(s==7)                                                                                                                  //
  217.                 {                                                                                                                          //
  218.                 s=0;                                                                                                                  //
  219.                 }                                                                                                                          //
  220.         }                                                                                                                                  //
  221. }                                                                                                                                          //
  222. //////////////////////////*主函数*//////////////////////////////////////
  223. void main()                                                                                                                          //
  224. {                                                                                                                                          //
  225.     dingshi();                                                                                                                  //
  226.         while(1)                                                                                                                  //
  227.         {                                                                                                                                  //
  228.         key();                                                                                                                          //
  229.         xianshi();                                                                                                                  //
  230.         }                                                                                                                                  //
  231. }                                                                                                                                          //
  232. ////////////////////////////////////////////////////////////////////////
复制代码


秒表}}}}}加功能键.zip

74.15 KB, 下载次数: 21, 下载积分: 黑币 -5

写得有点特殊



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