找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2740|回复: 0
收起左侧

单片机秒表+功能键 仿真+源程序

[复制链接]
ID:128610 发表于 2016-6-29 20:57 | 显示全部楼层 |阅读模式
0.png 仅供参考

源程序:



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


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

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

写得有点特殊

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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