找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 7570|回复: 4
收起左侧

51单片机电子跑表课程设计报告 含源代码,原理图,word文档

[复制链接]
ID:337138 发表于 2018-5-24 11:03 | 显示全部楼层 |阅读模式
课程设计任务书

课题名称

电子跑表的设计

姓    名

陈*

专业

测控技术

班级

1401

学号

04

指导老师

肖*

课程设计时间

(1-2周)

一、任务及要求

设计任务:

    利用单片机为核心设计一个多功能电子表,具有电时钟和跑表功能。用做时钟时,在显示器上显示时、分、秒,用做跑表时,显示范围00时00分00秒-23时59分59秒并具有跑表启动和跑表复位功能键。当按下启动按钮跑表开始计时,按下停止按停止计时,当按下复位按钮跑表回零。
设计要求:
  1)确定系统设计方案;
  2)进行系统的硬件设计;
  3)完成必要的参数计算与元器件选择;
  4)完成应用程序设计;
  5)应用系统的硬件和软件的调试。
二、进度安排
第一周:
周一:集中布置课程设计任务和相关事宜,查资料确定系统总体方案。
周二~周三:完成硬件设计和电路连接
周四~周日:完成软件设计
第二周:
周一~周三:程序调试
周四~周五:设计报告撰写。周五进行答辩和设计结果检查。
三、参考资料
1、王迎旭等.单片机原理及及应用[M]. 2版.机械工业出版社,2012
2、胡汉才.单片机原理及其接口技术[M].3版.清华大学出版社,2010.
3、戴灿金.51单片机及其C语言程序设计开发实例[M].清华大学出版社,2010



目录

第1章 总体方案设计            
1.1设计任务与要求            
1.2设计原理或者设计思路            
第2章 硬件电路设计
2.2显示电路            
2.3控制电路            
第3章 软件设计            
3.1系统主程序            
3.2系统子程序            
3.3中断服务程序            
第4章 调试            
4.1系统调试方法            
4.2调试结果            
4.3调试中遇到的问题及其解决方法            
总结
附录一
附录二

第1章 总体方案设计

1.1设计任务与要求

1.1.1设计任务:

利用单片机为核心设计一个多功能电子表,具有电时钟和跑表功能。用做时钟时,在显示器上显示时、分、秒,用做跑表时,显示范围00时00分00秒-23时59分59秒并具有跑表启动和跑表复位功能键。当按下启动按钮跑表开始计时,按下停止按停止计时,当按下复位按钮跑表回零。
1.1.2设计要求:
  1)确定系统设计方案;
  2)进行系统的硬件设计;
  3)完成必要的参数计算与元器件选择;
  4)完成应用程序设计;
  5)应用系统的硬件和软件的调试。
1.2设计原理或者设计思路
电子跑表的电路由多个部分组成,如控制按键的输入电路,单片机的时钟电路,复位电路 ,显示电路,秒表电路,LED显示器段码驱动电路,LED显示器位码驱动电路及秒表记录电路组成。
本电子跑表采用AT89C52单片机为核心器件,AT89C52是一个低电压,高性能CMOS8位单片机,片内含8k bytes的可反复擦写的Flash只读程序存储器和256 bytes的随机存取数据存储器(RAM),器件采用ATMEL公司的高密度、非易失性存储技术生产,兼容标准MCS-51指令系统,片内置通用8位中央处理器和Flash存储单元,AT89C52单片机在电子行业中有着广泛的应用。
AT89C52有40个引脚,32个外部双向输入/输出(I/O)端口,同时内含2个外中断口,3个16位可编程定时计数器,2个全双工串行通信口,2 个读写口线,AT89C52可以按照常规方法进行编程,也可以在线编程。其将通用的微处理器和Flash存储器结合在一起,特别是可反复擦写的 Flash存储器可有效地降低开发成本。
  将LED数码管与单片机和开关连接,用于显示时钟与跑表。P3.2-P3.4分别接开关K1-K3,P3.5和P3.6接开关K4,P1.0-P1.5接LED数码管输出位码,P0.0-P0.7输出显示段码。电子跑表是利用单片机内部的定时器来实现的,首先设置单片机内部的一个定时器1对秒表数据处理,定时器0对时间数据处理。
在本设计中LED数码显示器采用的是共阴极接法,把发光二极管的阴极连在一起构成 公共阴极,使用时公共阴极接地,每个发光二极管的阳极通过电阻与输入端相连。当阳极端输入高电平时,段发光二极管就导通点亮,而输入低电平时则不亮。
第2章 硬件电路设计            

2.1时钟电路

单片机工作的时间基准是由时钟电路提供的。在单片机的XTAL1和XTAL2两个管脚,接一只晶振及两只电容就构成了单片机的时钟电路。

图2.1.1  时钟电路

图2.1.2 单片机
2.2显示电路
本设计显示用的是四位七段显示共阴数码管,用来显示时间及跑表参数,LED数码管显示器成本低,配置灵活,与单片机接口简单,在单片机应用系统中广泛应用。
为了将时间显示在LED数码管上,可采用静态显示法和动态显示法,由于静态显示法需要译码器,数据锁存器等较多硬件,可采用动态显示法实现LED显示,通过对每位数码管的依次扫描,使对应数码管亮,同时向该数码管送对应的字码,使其显示数字。由于数码管扫描周期很短和人眼的视觉暂留效应,使数码管看起来总是亮的,从而实现了各种显示。
LED显示流程图如下:


图2.2.1  显示程序流程图
图2.2.2  LED数码显示管
2.3控制电路
K1键:模式选择,可以让时钟、秒表、时间设置及秒表的记录进行切换;
K2键:加一、开始及暂停,设置时间设置时可以调节时和分加一,秒表记录时可以开始和暂停;
K3键:切换和清零,当需要设置时间时,按下K3可以切换‘时’和‘分’;当显示秒表时,K3具有清零功能;
K4键:记录秒表,电路为秒表功能时,按下K4可以记录一组秒表数据,最多可以记录20组数据。
                           图2.3  开关控制电路

第3章 软件设计

3.1系统主程序
主要进行定时器的初始化编程,然后反复调用显示子程序的方法,等待中断的到来。K1是模式选择开关,当K1没有按下时,数码管表示时间;当K1第一次按下时,数码管表示秒表;当K1第二次按下时,数码管表示时间设置,并可以闪烁定位;当K1第三次按下时,数码管显示秒表记录。
主程流程图如下:单片机源程序如下:

图3.1 主程序流程图

3.2系统子程序
子程序包括时钟设置显示程序,时钟运行显示程序,时钟溢出入口程序,跑表暂停,跑表记录数据程序。
3.2.1显示时钟模式
如果K1=0时,程序设定为12.00.00起始计时,通过计数方式进行满60秒分钟位进一,满60分小时位进一,满24小时小时位清零。
3.2.2时间设置模式
如果K1=2时,先判断是否为时间设置模式,再判断K2是否按下,需要判断是否为误按,所以需要延时消抖,然后检测用户需要设置时还是分。
设置分,则跳到59之后重新赋值为0;
设置时,则跳到23之后重新赋值为0 。
K3每按一次Set0取反,时分切换,Set0为0时设置‘分’,Set0为1时设置‘时’。设置时间时用if语句实现分和钟以0.5秒的频率闪烁。
3.2.3秒表模式
如果K1=1时,先判断是否为秒表模式,再判断K2是否按下,需要判断是否为误按,所以需要延时消抖,K2每按一次TR1取反,暂停或开始定时器1,达到暂停或开始秒表的目的。当K4按下时秒表记录一组数据。当K3按下时清除所有秒记录数据,并停止定时器1。
3.2.4秒表记录显示模式
如果K1=3时,先判断是否为秒表记录显示模式,再判断K2是否按下,需要判断是否为误按,所以需要延时消抖,将秒表的记录分为4组,可存20组数据。当K3按下时秒表所有数据清零,并停止定时器1。
定时器1函数对于秒表数据处理,每两次循环进行一次操作,这样秒表1(1/10秒位)每加1次为0.1s。当秒表1(1/10秒位)加到10时,重新赋值为0,此时秒表2(秒位)开始增加;当秒表2(秒位)加到60时,重新赋值为0,此时秒表3(分位)开始增加;当秒表3(分位)加到60时,重新赋值为0,此时秒表4(时位)开始增加;当秒表4(时位)加到10时,重新赋值为0。
定时器0函数每溢出10次Time0_bit取反一次,时间间隔为0.5秒闪烁一次,以达到时间设置模式时,分和时的闪烁。
3.3中断服务程序
中断服务程序的作用是进行计时操作,定时器0和定时器1都选择第1种工作方式。定时器0和定时器1装初值,定时50ms。

中断服务程序流程图如下:

图3.3  中断程序流程图
第4章 调试4.1系统调试方法
本次课程设计采用的是Proteus仿真软件进行电路的仿真,编程使用Keil生成可执行文件加载到单片机中,通过对各个模块程序的单步或跟踪调试,使程序正确,最后统调程序,并生成相应的*.hex文件。进行程序的运行和调试,观察显示结果,根据显示的结果和课题的要求再修改程序,再运行查找错误,直到满足要求。
4.2调试结果
K1键表示模式选择,可以让时钟、秒表、时间设置及秒表的记录进行切换;
K2表示加一、开始及暂停,设置时间设置时可以调节时间,秒表记录时可以开始和暂停;
K3表示切换和清零,当需要设置时间时,按下K3可以切换‘时’和‘分’;当显示秒表时,K3具有清零功能;
K4表示记录秒表,电路为秒表功能时,按下K4可以记录一组秒表数据。

          图4.2.1  秒表时的调试结果
       图4.2.2  时钟调试结果


4.3调试中遇到的问题及其解决方法
按下K4记录秒表数据时,当记录次数大于20时,还是会继续保存数据,但由于AT89C52单片机内存不够,保存次数多了就会出现乱码。发现这个问题后小组成员检查程序是否有错,然后在同学的帮助下修改了程序。
总结
在课程设计第一天,老师带领我们焊电路板,为之后的实物连接做准备,有了上学期电子实习的经验,这次焊接很迅速,半天就焊好了两块电路板,在老师的帮助下顺利仿真。
课程设计开始几天,基本上没有收获,不知从何下手,不知所措。为了看得更远,,不妨站在前人的肩膀上,我在整体思路模糊的情况下,在网上找资料。也自己研究了一下Proteus仿真软件的使用,仔细研究AT89C52芯片的主要功能及管脚接法,这也就为后面比较成功的仿真出结果打下了基础。随着涉猎的点滴积累,我对电子跑表的设计方案已经慢慢酝酿而成,有了方向和不少知识储备后,在接下来的几天,几乎每天都有突破,虽然有时只是一句程序的修改或诞生,但那种收获一直激励着我。当然在设计过程中也遇到了一些问题,比如秒表记录次数超过20次后会出现乱码情况,在老师的指导下,经过一次又一次的思考,一遍又一遍的检查,我终于发现了问题所在,也暴露了前期我在这方面的知识欠缺和经验不足。实践才是检验真理的唯一标准,唯有通过亲自动手才能令我们掌握的知识不再是纸上谈兵的东西。
    经过一周的课程设计,我收获颇多,有深刻的心得体会,实践让我们受益匪浅。首先是单片机方面,为了顺利完成程序的编写,我又捡起了大一所学习的C语言知识。其次锻炼了小组合作的能力,合理的分工让我们组的课程设计按时完成,并对本专业的课程充满了浓厚的兴趣,相信有了兴趣,我在以后对本专业的学习会更加得心应手。在这次过程中我们也曾灰心也曾茫然,也曾不知所措,从一开始的自信满满,到最后的紧张繁杂,所有这些都令我回味无穷,这已经成为我人生道路上的宝藏。我想今后的学习和工作也是这样的,汗水见证成功。
附录一
  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. uchar code Tab0[]=                            //定义数码管数组,没有小数点
  5. {
  6.               0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f
  7. };
  8. uchar code Tab1[]=                            //定义数码管数组,有小数点
  9. {            
  10.               0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef
  11. };
  12. uchar miaobiao[80];                            //定义存储秒表数组
  13. sbit K1=P3^2;                                          //模式选择键,本程序三种模式,分别是时间显示、秒表、时间设置
  14. sbit K2=P3^3;                                          //设置时间时加一/开始(暂停)秒表按键
  15. sbit K3=P3^4;                                          //切换设置位/清零秒表按键
  16. sbit K4=P3^5;                                          //秒记录
  17. void Delay(uchar x);                            //延时函数
  18. void Display0();                             //时间显示函数
  19. void Display1();                             //秒表显示函数
  20. void Display2();                            //时间设置显示函数
  21. void Display3();                            //保存的秒表显示函数
  22. void Init();                                           //中断初始化函数
  23. void Mode_K1();                                          //模式切换函数
  24. void KEY_MiaoBiao();              //检测秒表操作按键
  25. void KEY_Time_Set();              //检测时间设置按键
  26. void KEY_MiaoBiao_keep();              //检测秒表记录显示按键操作            
  27. uchar Hours=12,Minutes=00,seconds=00;                            //分别定义三个变量表示时、分、秒
  28. uchar Time0_bit=0;                                          //用于定时器0的溢出标志
  29. bit Set_Time=0;                                                        //设置时 闪烁时长的标志位
  30. bit Set0=0;                                                                      //设置时间标志,确定是设置‘分’还设置‘时’
  31. uchar K1_bit=0,m=0;                                                          //用于模式切换的标志
  32. uchar Miao_Biao0,Miao_Biao1,Miao_Biao2,Miao_Biao3,Miao_Biao4;                            //用于秒表的变量
  33. uchar Miao_Biao11,Miao_Biao22,Miao_Biao33,Miao_Biao44;    //用于保存秒表显示时的变量
  34. void main()
  35. {
  36.               Init();                                                                                                                                            //中断初始化
  37.               while(1)                                                                                                                              //死循环
  38.                             {
  39.                                           Mode_K1();                                                                                                  //模式扫描
  40.                                           switch(K1_bit)                                                                                    //模式选择
  41.                                                         {
  42.                                                                       case 0:
  43.                                                                                     {
  44.                                                                                                   Display0();                                          //显示时间                                                                                                               
  45.                                                                                                   break;
  46.                                                                                     }
  47.                                                                       case 1:
  48.                                                                                     {
  49.                                                                                                   Display1();                                          //显示秒表
  50.                                                                                                   KEY_MiaoBiao();                            //扫描秒表操作
  51.                                                                                                   break;
  52.                                                                                     }
  53.                                                                       case 2:
  54.                                                                                                   {
  55.                                                                                                                 Display2();              //设置时间时的显示程序,可闪烁定位
  56.                                                                                                                 KEY_Time_Set();              //扫描按键
  57.                                                                                                                 break;
  58.                                                                                                   }
  59.                                                            case 3:
  60.                                                                                     {
  61.                                                                                                   Display3();                                          //显示秒表
  62.                                                                                                   KEY_MiaoBiao_keep();                            //扫描秒表操作
  63.                                                                                                   break;
  64.                                                                                     }
  65.                                                         }
  66.                             }
  67. }
  68. void KEY_Time_Set()                                                                                                                   //设置时间时的按键扫描函数
  69. {
  70.               if(K1_bit==2)                                                                                                                  //判断是否为时间设置模式
  71.                             {
  72.                                           if(K2==0)                                                                                                  //K2有按下(下同)
  73.                                                         {
  74.                                                                       Delay(10);                                                                         //延时消抖(下同)
  75.                                                                       if(K2==0)                                                                      //再次检测是否为误按
  76.                                                                                     {
  77.                                                                                                   if(Set0==0)                                          //检测是设置‘时’还是分,Set0为0时设置‘分’,Set0为1时设置‘时’
  78.                                                                                                                 {
  79.                                                                                                                               Minutes++;               //‘分’加1
  80.                                                                                                                               if(Minutes==60)              //当'分'加到60时,重新赋值0
  81.                                                                                                                                             Minutes=0;
  82.                                                                                                                 }
  83.                                                                                                   else
  84.                                                                                                                 {
  85.                                                                                                                               Hours++;                  //‘时’加1
  86.                                                                                                                               if(Hours==24)                //当'时'加到24时,重新赋值0
  87.                                                                                                                                             Hours=0;
  88.                                                                                                                 }
  89.                                                                                                   while(!K2);//按键松开检测,消除松开按键时的抖动干扰
  90.                                                                                     }
  91.                                                         }
  92.                                           if(K3==0)
  93.                                                         {
  94.                                                                       Delay(10);
  95.                                                                       if(K3==0)
  96.                                                                                     {
  97.                                                                                                   Set0=~Set0;              //K3每按一次Set0取反,时分切换,Set0为0时设置‘分’,Set0为1时设置‘时’
  98.                                                                                                   while(!K3);
  99.                                                                                     }            
  100.                                                         }
  101.                             }
  102. }
  103. void KEY_MiaoBiao()                                                                                                                //检测秒表按键操作
  104. {
  105.               if(K1_bit==1)                                                                                                                //判断是否为秒表模式
  106.                             {
  107.                                           if(K2==0)
  108.                                                         {
  109.                                                                       Delay(10);
  110.                                                                       if(K2==0)
  111.                                                                                     {
  112.                                                                                                   TR1=~TR1;                  //K2每按一次TR1取反,0暂停或1开始定时器1,达到暂停或开始秒表的目的
  113.                                                                                                   while(!K2);
  114.                                                                                     }
  115.                                                         }
  116.                                                         if(K4==0)                                                                                       //当K4按下时秒表记录一组数据
  117.                                                         {
  118.                                                                       Delay(10);
  119.                                                                       if(K4==0)
  120.                                                                       {
  121.                                                                                     miaobiao[4*m]=Miao_Biao1;
  122.                                                                                     miaobiao[4*m+1]=Miao_Biao2;
  123.                                                                                     miaobiao[4*m+2]=Miao_Biao3;
  124.                                                                                     miaobiao[4*m+3]=Miao_Biao4;
  125.                                                                                     m++;
  126.                                                                                     while(!K4);
  127.                                                                       }            
  128.                                                         }
  129.                                           if(K3==0)
  130.                                                         {
  131.                                                                       Delay(10);
  132.                                                                       if(K3==0)                            //当K3按下时秒表所有数据清零,并停止定时器1
  133.                                                                                     {
  134.                                                                                                   uchar i;
  135.                                                                                                   for(i=0;i<81;i++)
  136.                                                                                                   {
  137.                                                                                                                 miaobiao[i]=0;              //清除所有秒记录数据
  138.                                                                                                   }
  139.                                                                                                   TR1=0;                                                        //停止定时器1
  140.                                                                                                   Miao_Biao0=0;                             //清零数据
  141.                                                                                                   Miao_Biao1=0;
  142.                                                                                                   Miao_Biao2=0;
  143.                                                                                                   Miao_Biao3=0;
  144.                                                                                                   Miao_Biao4=0;
  145.                                                                                                   m=0;                                                        //秒表记录清零
  146.                                                                                                   while(!K3);
  147.                                                                                     }
  148.                                                         }
  149.                             }
  150. }
  151. void KEY_MiaoBiao_keep()                                                                                                                //检测秒表记录显示按键操作
  152. {
  153.               if(K1_bit==3)                                                                                                                //判断是否为秒表记录显示模式
  154.                             {
  155.                                                                                    
  156.                                           if(K2==0)
  157.                                                         {
  158.                                                                       Delay(10);
  159.                                                                       if(K2==0)
  160.                                                                                     {
  161.                                                                                                   m++;
  162.                                                                                                   while(!K2);
  163.                                                                                     }
  164.                                                         }
  165.                                           Miao_Biao11=miaobiao[4*m];
  166.                                           Miao_Biao22=miaobiao[4*m+1];
  167.                                           Miao_Biao33=miaobiao[4*m+2];
  168.                                           Miao_Biao44=miaobiao[4*m+3];
  169. if(K3==0)
  170.                                                         {
  171.                                                                       Delay(10);
  172.                                                                       if(K3==0)                            //当K3按下时秒表所有数据清零,并停止定时器1
  173.                                                                                     {
  174.                                                                                                     uchar i;
  175.                                                                                                   for(i=0;i<81;i++)
  176.                                                                                                   {
  177.                                                                                                                 miaobiao[i]=0;              //清除所有秒记录数据
  178.                                                                                                   }
  179.                                                                   while(!K3);
  180.                                                                                     }
  181.                                                         }
  182.                             }
  183. }
  184. void Mode_K1()              //模式选择键,本程序三种模式,分别是时间显示、秒表、时间设置
  185. {
  186.               if(K1==0)
  187.                             {
  188.                                           Delay(10);
  189.                                           if(K1==0)
  190.                                                         {
  191.                                                                       K1_bit++;
  192.                                                         //              if(K1_bit==1) m=0;
  193.                                                                       if(K1_bit==3) m=0;
  194.                                                                       if(K1_bit==4)
  195.                                                                                     {
  196.                                                                                                   K1_bit=0;
  197.                                                                                     }
  198.                                                                       while(!K1);


  199. /***********************************************************************
  200. *************当K1_bit为0时显示时钟,为1时进入秒表,*********************
  201. *******************为2时进入时间设置模式,3时进入秒表记录显示***********
  202. ***********************************************************************/
  203.                                                         }
  204.                             }
  205. }
  206.               void Time1() interrupt 3                                            //定时器1函数
  207. {
  208.               TH1=(65536-50000)/256;                                          //重装初值
  209.               TL1=(65536-50000)%256;
  210. Miao_Biao0++;
  211.               if(Miao_Biao0==2)                                                        //以下为秒表数据处理,每两次循环进行一次操作
  212.                             {
  213.                                           Miao_Biao0=0;
  214.                                           Miao_Biao1++;                                          //Miao_Biao1每加1次为100ms
  215.                                           if(Miao_Biao1==10)
  216.                                                         {
  217.                                                                       Miao_Biao1=0;
  218.                                                                       Miao_Biao2++;
  219.                                                                       if(Miao_Biao2==60)
  220.                                                                                     {
  221.                                                                                                   Miao_Biao2=0;
  222.                                                                                                   Miao_Biao3++;
  223.                                                                                                   if(Miao_Biao3==60)
  224.                                                                                                                 {
  225.                                                                                                                               Miao_Biao3=0;
  226.                                                                                                                               Miao_Biao4++;
  227.                                                                                                                               if(Miao_Biao4==10)
  228.                                                                                                                                             Miao_Biao4=0;
  229.                                                                                                                 }
  230.                                                                                     }
  231.                                                         }
  232.                             }
  233. }
  234. void Time0() interrupt 1                                                                       //定时器0函数
  235. {
  236.               TH0=(65536-50000)/256;                                                                         //重装初值
  237.               TL0=(65536-50000)%256;
  238.               Time0_bit++;
  239.               if((Time0_bit%10)==0)                                                                      //每溢出10次Time0_bit取反一次
  240.                             Set_Time=~Set_Time;                                                                        //0.5秒闪烁一次
  241. if(Time0_bit==20)                                                                                    //以下为时间数据处理
  242.                             {
  243.                                           Time0_bit=0;
  244.                                           seconds++;
  245.                                           if(seconds==60)
  246.                                                         {
  247.                                                                       seconds=0;
  248.                                                                       Minutes++;
  249.                                                                       if(Minutes==60)
  250.                                                                                     {
  251.                                                                                                   Minutes=0;
  252.                                                                                                   Hours++;
  253.                                                                                                   if(Hours==24)
  254.                                                                                                                 {
  255.                                                                                                                               Hours=0;
  256.                                                                                                                 }
  257.                                                                                     }
  258.                                                         }
  259.                             }
  260. }
  261. void Init()                                                                                                  //中断初始化函数
  262. {
  263.               EA=1;                                                                                                  //开总中断
  264.               TMOD=0X11;                                                                                      //定时器工作方式选择,定时器0和定时器1都选择第1种工作方式
  265.               TH0=(65536-50000)/256;                                          //定时器0装初值,定时50ms
  266.               TL0=(65536-50000)%256;
  267.               ET0=1;                                                                                                  //开定时器0开关
  268.               TR0=1;                                                                                                     //开定时器0小开关
  269.               TH1=(65536-50000)/256;                                          //定时器1装初值,定时50ms
  270.               TL1=(65536-50000)%256;
  271.               ET1=1;                                                                                                    //开定时器1开关
  272.               TR1=0;                                                                                                  //关定时器1小开关
  273. }
  274. void Display3()                                          //显示保存的秒表
  275. {
  276.               P0=Tab0[Miao_Biao11%10];                            //显示1/10秒的个位
  277.               P1=0xdf;                                                                      //段选
  278.               Delay(10);                                                                      //延时
  279.               P0=0X00;                                                                      //消隐
  280.               P0=Tab1[Miao_Biao22%10];                            //显示秒的个位,需要加上小数点做分隔符
  281.               P1=0xef;                                                                      //段选
  282.               Delay(10);                                                                      //延时
  283.               P0=0X00;                                                                      //消隐
  284.               P0=Tab0[Miao_Biao22/10];                            //显示秒的十位
  285.               P1=0xf7;                                                                      //段选
  286.               Delay(10);                                                                      //延时
  287.               P0=0X00;                                                                      //消隐
  288.               P0=Tab1[Miao_Biao33%10];                            //显示分的个位,需要加上小数点做分隔符
  289.               P1=0xfb;                                                                      //段选
  290.               Delay(10);                                                                      //延时
  291.               P0=0X00;                                                                      //消隐
  292.               P0=Tab0[Miao_Biao33/10];                            //显示分的十位
  293.               P1=0xfd;                                                                      //段选
  294.               Delay(10);                                                                      //延时
  295.               P0=0X00;                                                                      //消隐
  296.               P0=Tab1[Miao_Biao44%10];                            //显示时的个位,需要加上小数点做分隔符
  297.               P1=0xfe;                                                                      //段选
  298.               Delay(10);                                                                      //延时
  299.               P0=0X00;                                                                      //消隐
  300. }
  301. void Display2()                                                                                                  //时间设置时的显示函数            
  302. {
  303.               if(Set0==0)                                                                                                  //判断是否为设置‘时’还是‘分’
  304.                             {
  305.                                           P0=Tab0[seconds%10];                            //显示秒的个位
  306.                                           P1=0xdf;                                                                      //段选
  307.                                           Delay(10);                                                                      //延时
  308.                                           P0=0X00;                                                                      //消隐
  309.                                           P0=Tab0[seconds/10];                            //显示秒的十位
  310.                                           P1=0xef;                                                                      //段选
  311.                                           Delay(10);                                                                      //延时
  312.                                           P0=0X00;                                                                      //消隐
  313.                                           if(Set_Time)                                                        //这个if语句实现分钟以0.5秒的频率闪烁
  314.                                                         {
  315.                                                                       P0=Tab1[Minutes%10];              //显示分的个位,需要加上小数点做分隔符
  316.                                                                       P1=0xf7;                                                                      //段选
  317.                                                                       Delay(10);                                                                      //延时
  318.                                                                       P0=0X00;                                                                      //消隐
  319.                                                                       P0=Tab0[Minutes/10];                            //显示分的十位
  320.                                                                       P1=0xfb;                                                                      //段选
  321.                                                                       Delay(10);                                                                      //延时
  322.                                                                       P0=0X00;                                                                      //消隐
  323.                                                         }
  324.                                           else
  325.                                                         {
  326.                                                                       P0=0x00;                            //显示分的个位,需要加上小数点做分隔符
  327.                                                                       P1=0xf7;                                                                      //段选
  328.                                                                       Delay(10);                                                                      //延时
  329.                                                                       P0=0X00;                                                                      //消隐
  330.                                                                       P0=0x00;                                      //显示分的十位
  331.                                                                       P1=0xfb;                                                                      //段选
  332.                                                                       Delay(10);                                                                      //延时
  333.                                                                       P0=0X00;                                                                      //消隐
  334.                                                         }
  335.                                           P0=Tab1[Hours%10];              //显示时的个位,需要加上小数点做分隔符
  336.                                           P1=0xfd;                                                                      //段选
  337.                                           Delay(10);                                                                      //延时
  338.                                           P0=0X00;                                                                      //消隐
  339.                                           P0=Tab0[Hours/10];                            //显示时的十位
  340.                                           P1=0xfe;                                                                      //段选
  341.                                           Delay(10);                                                                      //延时
  342.                                           P0=0X00;                                                                      //消隐
  343.                             }
  344. else                                          //‘时’钟闪烁
  345.                             {
  346.                                           P0=Tab0[seconds%10];                            //显示秒的个位
  347.                                           P1=0xdf;                                                                      //段选
  348.                                           Delay(10);                                                                      //延时
  349.                                           P0=0X00;                                                                      //消隐
  350.                                           P0=Tab0[seconds/10];                            //显示秒的十位
  351.                                           P1=0xef;                                                                      //段选
  352.                                           Delay(10);                                                                      //延时
  353.                                           P0=0X00;                                                                      //消隐
  354.                                           P0=Tab1[Minutes%10];                            //显示分的个位,需要加上小数点做分隔符
  355.                                           P1=0xf7;                                                                      //段选
  356.                                           Delay(10);                                                                      //延时
  357.                                           P0=0X00;                                                                      //消隐
  358.                                           P0=Tab0[Minutes/10];                            //显示分的十位
  359.                                           P1=0xfb;                                                                      //段选
  360.                                           Delay(10);                                                                      //延时
  361.                                           P0=0X00;                                                                      //消隐
  362.                                           if(Set_Time)                                                        //这个if语句实现‘时’钟以0.5秒的频率闪烁
  363.                                                         {
  364.                                                                       P0=Tab1[Hours%10];              //显示时的个位,需要加上小数点做分隔符
  365.                                                                       P1=0xfd;                                                                      //段选
  366.                                                                       Delay(10);                                                                      //延时
  367.                                                                       P0=0X00;                                                                      //消隐
  368.                                                                       P0=Tab0[Hours/10];                            //显示时的十位
  369.                                                                       P1=0xfe;                                                                      //段选
  370.                                                                       Delay(10);                                                                      //延时
  371.                                                                       P0=0X00;                                                                      //消隐
  372.                                                         }
  373.                                           else
  374.                                                         {
  375.                                                                       P0=0x00;                                          //显示时的个位,需要加上小数点做分隔符
  376.                                                                       P1=0xFF;                                                                      //段选
  377.                                                                       Delay(10);                                                                      //延时
  378.                                                                       P0=0X00;                                                                      //消隐
  379.                                                                       P0=0X00;                                          //显示时的十位
  380.                                                                       P1=0xFF;                                                                      //段选
  381.                                                                       Delay(10);                                                                      //延时
  382.                                                                       P0=0X00;                                                                      //消隐                                                      
  383.                                                         }                           
  384.                             }
  385. }
  386. void Display1()                                          //显示秒表
  387. {
  388.               P0=Tab0[Miao_Biao1%10];                            //显示1/10秒的个位
  389.               P1=0xdf;                                                                      //段选
  390.               Delay(10);                                                                      //延时
  391.               P0=0X00;                                                                      //消隐
  392.               P0=Tab1[Miao_Biao2%10];                            //显示秒的个位,需要加上小数点做分隔符
  393.               P1=0xef;                                                                      //段选
  394.               Delay(10);                                                                      //延时
  395.               P0=0X00;                                                                      //消隐
  396.               P0=Tab0[Miao_Biao2/10];                            //显示秒的十位
  397.               P1=0xf7;                                                                      //段选
  398.               Delay(10);                                                                      //延时
  399.               P0=0X00;                                                                      //消隐
  400.               P0=Tab1[Miao_Biao3%10];                            //显示分的个位,需要加上小数点做分隔符
  401.               P1=0xfb;                                                                      //段选
  402.               Delay(10);                                                                      //延时
  403.               P0=0X00;                                                                      //消隐
  404.               P0=Tab0[Miao_Biao3/10];                            //显示分的十位
  405.               P1=0xfd;                                                                      //段选
  406.               Delay(10);                                                                      //延时
  407.               P0=0X00;                                                                      //消隐
  408.               P0=Tab1[Miao_Biao4%10];                            //显示时的个位,需要加上小数点做分隔符
  409.               P1=0xfe;                                                                      //段选
  410.               Delay(10);                                                                      //延时
  411.               P0=0X00;                                                                      //消隐
  412. }
  413. void Display0()                                          //显示时钟
  414. {
  415.               P0=Tab0[seconds%10];                            //显示秒的个位
  416.               P1=0xdf;                                                                      //段选
  417.               Delay(10);                                                                      //延时
  418.               P0=0X00;                                                                      //消隐
  419.               P0=Tab0[seconds/10];                            //显示秒的十位
  420.               P1=0xef;                                                                      //段选
  421.               Delay(10);                                                                      //延时
  422.               P0=0X00;                                                                      //消隐
  423.               P0=Tab1[Minutes%10];                            //显示分的个位,需要加上小数点做分隔符
  424.               P1=0xf7;                                                                      //段选
  425.               Delay(10);                                                                      //延时
  426.               P0=0X00;                                                                      //消隐
  427.               P0=Tab0[Minutes/10];                            //显示分的十位
  428.               P1=0xfb;                                                                      //段选
  429.               Delay(10);                                                                      //延时
  430.               P0=0X00;                                                                      //消隐
  431.               P0=Tab1[Hours%10];                                          //显示时的个位,需要加上小数点做分隔符
  432.               P1=0xfd;                                                                      //段选
  433.               Delay(10);                                                                      //延时
  434.               P0=0X00;                                                                      //消隐
  435.               P0=Tab0[Hours/10];                                          //显示时的十位
  436.               P1=0xfe;                                                                      //段选
  437.               Delay(10);                                                                      //延时
  438.               P0=0X00;                                                                      //消隐
  439. }
  440. void Delay(uchar x)                                                          //延时
  441. {
  442.               uchar i,j;
  443.               for(i=x;i>0;i--)
  444.                             for(j=110;j>0;j--);
  445. }
复制代码

所有资料51hei提供下载:
单片机课设.doc (310.88 KB, 下载次数: 76)
回复

使用道具 举报

ID:359904 发表于 2018-6-27 08:59 | 显示全部楼层
有仿真吗
回复

使用道具 举报

ID:310313 发表于 2018-6-27 11:24 | 显示全部楼层
为什么我的显示不一样
回复

使用道具 举报

ID:677724 发表于 2019-12-31 13:13 | 显示全部楼层
电路图有吗?朋友
回复

使用道具 举报

ID:793352 发表于 2020-7-8 16:31 | 显示全部楼层

同问,是用CAD还是protues
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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