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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于单片机的快棋赛电子计时器设计报告
返回列表 发新帖
查看: 2952|回复: 0
收起左侧

基于单片机的快棋赛电子计时器设计报告

[复制链接]
ID:368732 发表于 2018-7-10 15:13 | 显示全部楼层 |阅读模式
题目：
快棋赛电子计时器设计


第一部分 设计内容和要求

1.1设计内容

利用keil、Proteus和C51单片机设计出快棋赛电子计时器

1.2 设计要求

1. 八个数码管分为两组，每组四个数码管动态显示对应方的定时时间，以及倒计过程，包括分钟（2位，00~99）、秒（2位，00~59）
2. 相互控制启停开关（2个）
3. 总暂停开关（用于双方选手同时休息）
4. 各自初始时间设置（选手同意情况下可以设置不同的初始时间），即可以对相应的分钟及秒分别进行初始设置
5.  任何一方的选手如果时间倒计为零，则报警并在其四个数码管上闪烁显示“LOSE”

1.3系统运行流程

程序首先进行初始化，在主程序的循环中，首先调用数据处理函数，将分和秒数值拆开储存在显示缓冲区中（即一个数组中），然后按键扫描函数，判断是否有按键按下；若有，则执行相应程序，若没有；则往下功能指示灯led函数。若功能按键按下，则亮相应的led；若无，则继续往下执警告函数。若有时间快耗完了，则执行相应程序；若无，则继续往下结束函数，若时间耗完了，则执行相应程序；若无，执行循环。这里，我用了定时器0和定时器1，定时器0用来计时间，定时器1用做动态显示。
第二部分 设计方案

程序流程


主程序流程图
按键扫描子程序
检测是否有按键按下，若无返回主程序；
若K1按下，若计时开始且功能按键记录次数为0，则是控制时间作用：红色时间暂停，蓝色时间开始；若计时暂停且功能按键记录次数不为0，则是调节时间作用：根据功能按键次数，增加对应数值
若K2按下，若计时开始且功能按键记录次数为0，则是控制时间作用：蓝色时间暂停，红色时间开始；若计时暂停且功能按键记录次数不为0，则是调节时间作用：根据功能按键次数，减少对应数值
若K3按下，全部时间暂停或者开启；（一开始时，时间都是暂停的，只有当K3按下时，红色方先开始计时）
若K4按下，记录按下次数；（作为功能按键，让K1和K2调整红色分和秒数值以及蓝色分秒数值）
（注：当程序开始计时时或比赛结束时，K4按键无效）

功能指示灯程序（附加功能）
共有4个led作为指示灯，根据功能按键按下次数，亮不同的led，作为指示灯，告知使用者，你正在调整的是哪个数值。

警告子程序（附加功能）
若有一方的时间少于十秒了，则代表他的两个led就会闪烁，作为提示。

结束子程序
当一方的时间耗完了，则他的数码管会闪烁“lose”，另一方闪烁显示“win”（附加功能），并且4个led也会一起闪烁（附加功能）。

定时器0
我用做秒计时，每当秒计时到了，根据判断，减少红色时间或减少蓝色时间。

定时器1
我用做数码管的动态显示；这样能消除按键带来的显示影响。
第三部分 Proteus电路图


第四部分 keil编译结果和Proteus仿真结果
Keil编译结果
Proteus仿真结果
编译和仿真都能通过没有问题。
第五部分 单片机仿真
第六部分 附加功能
在第二部分设计方案中，我已用红色字体标注出，这里不再赘述了。
第八部分设计心得及体会

本次课程设计中，特别是在程序编写过程中，遇到了很多的问题。但这是对我的考验一定要充满耐心，遇到问题，就去寻找解决问题的办法。我设计过程中还不断提出自己的疑点以及新的想法，联系实际应用，将课本上学习的东西运用到实际中，这些都令我受益匪浅。最终得以完成这次单片机课程设计，非常感谢老师教导。

第七部分 代码及注释
  1. #include <reg51.h>
  2. #define uchar  unsigned char
  3. #define uint unsigned int
  4. uchar DispBuf[8];  //显示缓冲区
  5. uchar DispTab[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,
  6.                                                         0x90,0x88,0x83,0xC6,0xA1,0x86,0x8E,0xFF};              //LED字形码
  7. uchar BitTab[]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01 };              //LED位驱动码
  8. uchar redlose[]={0xC1,0xC1,              0xF9,0xC8,0xC7,0xC0,0x92,0x84};//红色时间到LED字形码
  9. uchar bluelose[]={0xC7,0xC0,0x92,0x84,0xC1,0xC1,0xF9,0xC8};//蓝色时间到LED字形码
  10. sbit k1=P1^0;
  11. sbit k2=P1^1;
  12. sbit k3=P1^2;
  13. sbit k4=P1^3;
  14. sbit L1=P3^0;
  15. sbit L2=P3^1;
  16. sbit L3=P3^2;
  17. sbit L4=P3^3;
  18. uint num,flag1=1,flag2,flag3=1;,k4num;
  19. uchar miao1=00,fen1=30,miao2=00,fen2=30;
  20. void Timer1(void) interrupt 1{
  21.               TH0=(65536-50000)/256;//重装数值
  22.               TL0=(65536-50000)%256;
  23.               num++;
  24.               if(num==20)//如果到了20次，说明一秒时间到
  25.               {
  26.                             num=0;//清零，重新计数20次
  27.                             if(flag1==1)//红方时间减少
  28.                             {
  29.                                           miao1--;//秒时间减少
  30.                                           if(miao1==-1){//说明一分钟到了，重新减少一分钟，并且分钟减一
  31.                                                            miao1=59;
  32.                                                            fen1--;
  33.                                                            }
  34.                                                         }
  35.                   if(flag1==0)//蓝方时间减少
  36.                             {
  37.                                           miao2--;
  38.                                           if(miao2==-1){
  39.                                                            miao2=59;
  40.                                                            fen2--;
  41.                                        }
  42.                            
  43.                       }
  44.                }
  45.                                                            }
  46. void Timer2(void) interrupt 3{
  47.     uchar tmp;
  48.     uchar Count;
  49.               TH1=(65536-3000)/256;//重装数值
  50.               TL1=(65536-3000)%256;
  51.             
  52.               P2=BitTab[Count];              //取位值
  53.               tmp=DispBuf[Count];              //取出待显示的数
  54.               tmp=DispTab[tmp];              //取字形码
  55.               P0=tmp;
  56.               Count++;
  57.     if(Count==8)
  58.                             Count=0;
  59.             
  60.             
  61.                                         }
  62. void delay(uint xms)//延时函数
  63. {
  64.               uint i,j;
  65.               for(i=xms;i>0;i--)

  67.                             for(j=110;j>0;j--);
  68. }

  70. void keyscan(void)//按键函数
  71. {
  72.               if(k1==0)//按键按下
  73.               {
  74.                             delay(5);
  75.                             if(k1==0)//确认按键按下
  76.                             {
  77.                                          
  78.                                           while(!k1);//等待按键释放
  79.                                           if(k4num==0&&TR0==1)//当计时开始，并且功能键记录次数为零时，作用为控制时间
  80.                                           {
  81.                                                         if(flag1==1)//红色时间暂停，蓝色时间开始
  82.                                                                       flag1=0;
  83.                                                         }
  84.                                           if(k4num!=0&&TR0==0)//当计时暂停，并且功能键记录次数不为零，作用为调节时间
  85.                                           {
  86.                                           switch(k4num)//根据功能键次数，增加相应数值
  87.                                                         {
  88.                                                                       case 1: miao1++;
  89.                                                                                                   if(miao1==60)
  90.                                                                                                                 miao1=0;
  91.                                                                                                   break;
  92.                                                                       case 2: fen1++;
  93.                                                                                                   if(fen1==100)
  94.                                                                                                                 fen1=0;
  95.                                                                                                   break;
  96.                                                                       case 3: miao2++;
  97.                                                                                                   if(miao2==60)
  98.                                                                                                                 miao2=0;
  99.                                                                                                   break;
  100.                                                                       case 4: fen2++;
  101.                                                                                                   if(fen2==100)
  102.                                                                                                                 fen2=0;
  103.                                                                                                   break;
  104.                                                                                                   }
  105.                                                                                                   }
  106.                                                                       }
  107.                                                         }
  108.               if(k2==0){
  109.                             delay(5);
  110.                             if(k2==0){
  111.                                          
  112.                                           while(!k2);
  113.                                           if(k4num==0&&TR0==1)//
  114.                                           {
  115.                                                         if(flag1==0)//蓝色时间暂停，红色时间开始
  116.                                                                       flag1=1;
  117.                                                                                     }
  118.                                           if(k4num!=0&&TR0==0)//根据功能键次数，增加相应数值
  119.                                           {
  120.                                           switch(k4num)
  121.                                           {
  122.                                                                       case 1: miao1--;
  123.                                                                                                   if(miao1==-1)
  124.                                                                                                                 miao1=59;
  125.                                                                                                   break;
  126.                                                                       case 2: fen1--;
  127.                                                                                                   if(fen1==-1)
  128.                                                                                                                 fen1=99;
  129.                                                                                                   break;
  130.                                                                       case 3: miao2--;
  131.                                                                                                   if(miao2==-1)
  132.                                                                                                                 miao2=59;
  133.                                                                                                   break;
  134.                                                                       case 4: fen2--;
  135.                                                                                                   if(fen2==-1)
  136.                                                                                                                 fen2=99;
  137.                                                                                                   break;
  138.                                                                                                   }
  139.                                                            }
  140.                                                                       }
  141.                                                          
  142.                                                         }
  143.               if(k3==0)//总暂停开关
  144.               {
  145.                             delay(5);
  146.                             if(k3==1){
  147.                                           while(!k3);
  148.                                           TR0=~TR0;//控制时间暂停或是开始
  149.                                           k4num=0;//功能按键记录次数清零
  150.                                           flag3=0;//清零标志
  151.                                                                       }
  152.                                                         }
  153.               if(k4==0)//功能按键
  154.               {
  155.                             delay(5);
  156.                             if(k4==0){
  157.                                           if(TR0==0)//当计时暂停时，这个按键才有效
  158.                                           {
  159.                                                         flag3=1;//做标志，防止在调节时间时，调到零的时候，就进入子程序last（）
  160.                                                         k4num++;//记录功能按键按下次数
  161.                                                                       }
  162.                                                         if(k4num==5||TR0==1||flag2==1)//当带五次按下或开始计时或某一方时间耗完，清零记录次数
  163.                                                         {
  164.                                                                       k4num=0;
  165.                                                                                                 
  166.                                                                       }
  167.                                           while(!k4);
  168.                                                         }
  169.                                           }
  170.                            

  172. }
  173. void last()//某一方时间耗完，分别显示lose和win
  174. {
  175.               uint i,j;
  176.               if(miao1==0&&fen1==0&&flag3==0)//红方时间先耗完
  177.               {
  178.                             TR0=0;//关闭计时
  179.                             TR1=0;//关闭时间显示
  180.                             flag2=1;//标志比赛结束
  181.                             for(i=80;i>0;i--)//动态显示 lose和win 80次
  182.                             {
  183.                                           for(j=0;j<8;j++){
  184.                                                         P2=BitTab[j];//送入位选
  185.                                                         P0=redlose[j];//送入lose和win的字形码
  186.                                                         delay(2);
  187.                                                         P0=0xFF;
  188.                                                         }            
  189.                                           L1=~L1;//led不断闪烁
  190.                                 L2=~L2;
  191.                                           L3=~L3;
  192.                                           L4=~L4;
  193.                                           }
  194.                             P0=0XFF;//关闭显示300ms
  195.                             P2=0X00;
  196.                             delay(300);
  197.                             }
  198.               if(miao2==0&&fen2==0&&flag3==0)//蓝色方时间耗完
  199.               {
  200.                             TR0=0;
  201.                             TR1=0;
  202.                             flag2=1;
  203.                             for(i=70;i>0;i--){
  204.                                           for(j=0;j<8;j++){
  205.                                                         P2=BitTab[j];
  206.                                                         P0=bluelose[j];
  207.                                                         delay(3);
  208.                                                         P0=0xFF;
  209.                                                         }                                                                     
  210.                                           L1=~L1;
  211.                                 L2=~L2;
  212.                                           L3=~L3;
  213.                                           L4=~L4;            
  214.                             }
  215.                             P0=0XFF;
  216.                             P2=0X00;
  217.                             delay(100);
  218.                             }
  219.                             }
  220. void led()//功能按键对应的指示led灯亮或灭
  221. {
  222.               switch(k4num){
  223.                             case 0: P3=0xFF;
  224.                                                         break;
  225.                             case 1: P3=0xF7;
  226.                                               break;
  227.                             case 2: P3=0xFB;
  228.                                               break;
  229.                             case 3: P3=0xFD;
  230.                                                         break;
  231.                             case 4: P3=0xFE;
  232.                                                         break;
  233.                                                         }
  234.             

  236. }
  237. void warn(){
  238.               if(fen1==0&&miao1<10&&TR0==1&&flag1==1)//当红色时间少于十秒的时候，闪烁led灯提示
  239.               {
  240.                             L3=~L3;
  241.                             L4=~L4;
  242.                             }
  243.               if(fen2==0&&miao2<10&&TR0==1&&flag1==0)//当红色时间少于十秒的时候，闪烁led灯提示
  244.               {
  245.                             L1=~L1;
  246.                             L2=~L2;
  247.                             }

  249.                             }

  251. void zixing(){
  252.                             DispBuf[0]=fen2/10;
  253.                             DispBuf[1]=fen2%10;
  254.                             DispBuf[2]=miao2/10;
  255.                             DispBuf[3]=miao2%10;
  256.                             DispBuf[4]=fen1/10;
  257.                             DispBuf[5]=fen1%10;
  258.                             DispBuf[6]=miao1/10;
  259.                             DispBuf[7]=miao1%10;

  261. }                           
  262. void main(){
  263.               TMOD=0X11;//设置T0定时方式一和T1定时方式一
  264.               TH0=(65536-50000)/256;//装入初值，计时一秒
  265.               TL0=(65536-50000)%256;
  266.               TH1=(65536-3000)/256; //装入初值，计时30us
  267.               TL1=(65536-3000)%256;
  268.               EA=1;//打开总中断
  269.               ET0=1;//打开定时器0中断
  270.               ET1=1;//打开定时器1中断
  271.               TR0=0;//暂停定时器0
  272.               TR1=1;//开启定时器1
  273.               while(1){
  274.                             zixing();//将分和秒数值拆开，存入显示缓冲区，等待显示
  275.                             keyscan();//按键函数
  276.                             led();//功能指示led
  277.                             warn();//当时间少于十秒时，警告函数
  278.                             last();//比赛结束，显示lose和win 函数
  279.                                           }
  280.                                           }
复制代码
完整的Word格式文档51黑下载地址：
庞智仁2016160111.doc (695 KB, 下载次数: 23)

评分

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

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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