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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机智能秒表的制作与调试课程设计论文与资料下载
返回列表 发新帖
查看: 3311|回复: 5
打印 上一主题 下一主题
收起左侧

单片机智能秒表的制作与调试课程设计论文与资料下载

[复制链接]
跳转到指定楼层
楼主
ID:161768 发表于 2017-7-31 15:39 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式

单片机课程设计项目：智能秒表的设计与制作
一、项目任务：智能秒表的设计与制作

用四位LED数码管制作带小数显示的秒表，前两位显示整数部分（秒），后两位显示小数部分（百分之一秒）。

所设计的秒表最大计时时间为99秒99。

开始时，数码管显示“00. 00”，表明从0开始计时。

本智能秒表有两种时间计时模式。（注意：模式1与模式2用同一个程序实现，即当程序下载至单片机芯片后，只需要按下相应按键，该秒表可工作在任意一种模式下）

（一）基本部分：

1、模式1：累积计时模式

（1）按按键1可实现秒表开始、停止、再开始、再停止计时（时间累计）；

（2）计时完毕，按按键2计时归零。

2、模式2：间隔计时模式

（1） 按按键1开始计时；

（2） 按按键2一次暂停秒表并显示当前时间。间隔时间显示2秒后秒表将持续计时。（例如在3秒钟时秒表被暂停，2秒钟后秒表从5秒开始继续计时。显示2秒是为了方便记录当前时间）；

（3） 在下一点终止时再按按键2记录此时相关信息，如此重复；

（4） 当计时停止时按按键1；

（5）可通过按键3查看前面操作所记录的时间，最多可查看10个记录；

（6） 计时完毕，按按键2键计时归零。

（二）发挥部分

（1）用电脑时间校准秒表的时间，保证秒表走时的准确性（100秒的误差小于0.1秒），思考如何修改程序？

（2）利用内部E2PROM存储器（STC89C52自带），使智能秒表具有掉电数据不丢失的功能，思考如何修改程序？

（3）仿真无误后，购买元件制作该智能秒表，从商业价值考虑该智能秒表的美观性和实用性。

二、硬件电路及仿真效果图
三、STC90C52RC单片机引脚排列图
四、四位共阴极数码管引脚排列图
五、元器件清单
序号
元件名称
规格型号
数量
单价
合计
1
单片机
STC90C52RC
1
6
6
2
四位共阴数码管
3641AS
1
2
2
3
轻触按键
45*45mm
6
0.2
1.2
4
晶振
12MHz
1
0.5
0.5
5
瓷片电容
20pF
2
0.1
0.2
6
电解电容
10uF/10V
1
0.3
0.3
7
电阻
10KΩ
1
0.1
0.1
8
排电阻
1KΩ
1
0.5
0.5
9
单片机插座
40PIN
1
0.5
0.5
10
电路板
7cm×9cm
1
3
3
11
电池
+5V
1
3
3
12
外部存储器
AT24C04
1
2
2
共计


18

19.30元
七、调试方法和步骤
1、通电前先用万用表欧姆档（1KΩ档）测量电源两端正反向电阻，正向电阻约80KΩ，反向电阻约6.5KΩ。如果电阻很小，则说明有短路性故障，不能通电，排除短路故障后才能通电，如果电阻为无穷大，则有开路性故障。
2、通电后，测量单片机40脚与20脚之间的电压应该有5V左右，如果电压不正常，则说明单片机供电不正常，应重点检查单片机供电电路。
3、测量单片机晶振引脚18和19脚电压，应该在1.9～2.3V左右，两个引脚电压相差0.2V左右，如果这两个引脚电压不正常，说明晶振电路没有起振，重点检查晶振和补偿电容是否焊接好。
4、测量单片机复位引脚9脚，正常工作时电压为0V，按复位键时为5V，松开手后由5V逐渐降至0V。如果该脚电压不正常，说明复位电路有故障，需要检查该脚的电阻、电容的连接和焊接是否正确。
5、以上步骤的测量如果正常，则多数是单片机的软件问题，可以通过编写几个小程序单独调试I/O口、按键、数码管和存储器的功能，测试到底是软件问题还是硬件问题。
六、C语言程序
  1. /********************************/
  2. /* 智能秒表（使用内部EEPROM）*/
  3. /*--------------------------------------------*/
  4. /**（1）启动/停止功能         **/
  5. /**（2）复位/间隔功能          **/
  6. /**（3）两种工作模式           **/
  7. /**（4）查看数据功能           **/
  8. /**（5）断电记忆功能           **/
  9. /********************************/
  10. #include <reg52.h>
  11. #include <intrins.h>
  12. #define uint unsigned int
  13. #define uchar unsigned char

  15. #define RdCommand 0x01                             //定义内部EEPROM存储器部分
  16. #define PrgCommand 0x02
  17. #define EraseCommand 0x03
  18. #define Error 1
  19. #define Ok 0
  20. #define WaitTime 0x01
  21. sfr ISP_DATA=0xe2;
  22. sfr ISP_ADDRH=0xe3;
  23. sfr ISP_ADDRL=0xe4;
  24. sfr ISP_CMD=0xe5;
  25. sfr ISP_TRIG=0xe6;
  26. sfr ISP_CONTR=0xe7;

  28. sbit key1=P2^0;                //定义"启动/暂停"按钮
  29. sbit key2=P2^1;                //定义"复位"按钮
  30. sbit key3=P2^2;                                                        //定义"模式"按钮
  31. sbit key4=P2^3;                                                        //定义"查看"按钮
  32. sbit key5=P1^5;                                                        //定义"清除"按钮

  34. sbit wei1=P2^4;                                                        //定义位选
  35. sbit wei2=P2^5;
  36. sbit wei3=P2^6;              
  37. sbit wei4=P2^7;

  39. bit flag_start,flag_mode,flag_2sec,flag_CLR;
  40. uchar temp,temp1,aa,aa1,shi,ge,shifen,baifen,num,i=0;
  41. uchar time_data1[11],time_data2[11];
  42. uchar code table[]={                              //共阴极数码管编码
  43. 0x3f,0x06,0x5b,0x4f,
  44. 0x66,0x6d,0x7d,0x07,
  45. 0x7f,0x6f,0x77,0x7c,
  46. 0x39,0x5e,0x79,0x71,0x40};      

  48. void display(uchar shi,uchar ge,uchar shifen,uchar baifen);  //声明显示子函数
  49. void delay(uint z);           //声明延时子函数
  50. void init();                  //声明初始化函数
  51. void key();                                                          //声明键扫描函数
  52. void display_process();                              //声明显示处理函数
  53. void delayus();                                            //声明延时微秒函数                                          
  54. void data_read();                                            //声明内部EEPROM数据读出函数
  55. void clear();                                                          //声明清除EEPROM数据函数

  57. void ISP_IAP_enable(void);                //声明EEPROM操作函数
  58. void ISP_IAP_disable(void);
  59. void ISPgoon(void);
  60. uchar byte_read(uint byte_addr);
  61. void SectorErase(uint sector_addr);
  62. void byte_write(uint byte_addr, uchar original_data);
  63. void memory_read();                                            //声明EEPROM读函数
  64. void memory_write();                                   //声明EEPROM写函数

  66. void main()                                                                        //主函数
  67. {            
  68.               init();                                //调用初始化子程序
  69.               while(1)
  70.               {                           
  71.                 key();                                                                                       //调用按键扫描函数
  72.                 if(num==0&&i!=0)                                             //如果一开机就按查看键
  73.                   memory_read();                                             //调用EEPROM数据读出函数
  74.                 if(flag_CLR==1)                                                           //如果按了清除键
  75.                             clear();                                                                         //调用清除EEPROM数据函数
  76.                 display_process();                                             //调用显示处理函数
  77.                 display(shi,ge,shifen,baifen);      //调用显示函数   
  78.               }
  79. }

  81. void delay(uint z)                     //延时毫秒函数
  82. {
  83.               uint x,y;
  84.               for(x=z;x>0;x--)
  85.                             for(y=110;y>0;y--);
  86. }

  88. void display(uchar shi,uchar ge,uchar shifen,uchar baifen)   //显示程序
  89. {            
  90.                             P0=table[shi];        //使用动态扫描的方法实现数码管显示
  91.                             wei1=0;
  92.                             delay(1);
  93.                             wei1=1;

  95.                             if(flag_CLR==0)                              //正常显示时，第二位显示小数点
  96.                               P0=table[ge]|0x80;
  97.                             else                                                              //按清除键时，不显示小数点
  98.                               P0=table[ge];
  99.                             wei2=0;
  100.                             delay(1);            
  101.                             wei2=1;

  103.         P0=table[shifen];      //使用动态扫描的方法实现数码管显示
  104.                             wei3=0;
  105.                             delay(1);
  106.                             wei3=1;

  108.                             P0=table[baifen];
  109.                             wei4=0;
  110.                             delay(1);            
  111.                             wei4=1;            
  112. }

  114. void init()                        //初始化子程序
  115. {            
  116.               temp=0;
  117.               TMOD=0x01;                //使用定时器T0的方式1
  118.               TH0=(65536-10000)/256;
  119.               TL0=(65536-10000)%256;      //定时10ms中断一次
  120.               EA=1;                       //中断总允许
  121.               ET0=1;                      //允许定时器T0中断            
  122. }

  124. void key()                                                                                    //按键扫描函数
  125. {
  126.               uchar j;
  127.               if(key1==0)                 //检测"启动"按钮是否按下
  128.               {
  129.                             delay(5);                 //延时去抖动
  130.                             if(key1==0)             //再次检测"启动"按钮是否按下
  131.                             {            
  132.            while(!key1)         //松手检测（按下时数码管不灭）
  133.                                 {
  134.                                             display_process();                                          //调用显示处理函数
  135.                         display(shi,ge,shifen,baifen);  //调用显示函数
  136.                                           }
  137.                                flag_start=~flag_start;
  138.                                if(flag_start==1)
  139.                                           TR0=1;                    //启动定时器开始工作
  140.                                else
  141.                                           TR0=0;
  142.                             }
  143.               }
  144.                             if(key2==0)                    //检测"间隔"按钮是否按下  
  145.                             {
  146.                                           delay(5);        
  147.                                           if(key2==0)      
  148.                                           {            
  149.                                                         while(!key2)                                                                      //松手检测
  150.                                                         {
  151.                                                         display_process();                                              //调用显示处理函数
  152.                            display(shi,ge,shifen,baifen);   //调用显示函数
  153.                                                         }
  154.                                                         if(flag_mode==0||i!=0)
  155.                                                         {
  156.                                                           shi=0;            
  157.                                                           ge=0;
  158.                                                           shifen=0;
  159.                                                           baifen=0;
  160.                                                           aa=0;
  161.                                                           temp=0;
  162.                                                           TR0=0;
  163.                                                           i=0;
  164.                                                           num=0;
  165.                                                           for(j=0;j<=10;j++)
  166.                                                           {
  167.                                                             time_data1[j]=0;
  168.                                                             time_data2[j]=0;
  169.                                                           }
  170.                                                         }
  171.                                               else
  172.                                                {
  173.                                                            num++;
  174.                                                            if(num==11)
  175.                                                              num=1;
  176.                                                            memory_write();
  177.                                                         }
  178.                                           }
  179.                             }
  180.                             if(key3==0)
  181.                             {
  182.                               delay(5);
  183.                               if(key3==0)
  184.                                {
  185.                                  while(!key3)                                                                          //松手检测
  186.                                             {
  187.                                                         display_process();                                              //调用显示处理函数
  188.                           display(shi,ge,shifen,baifen);    //调用显示函数
  189.                                             }
  190.                                           flag_mode=~flag_mode;
  191.                                }
  192.                             }
  193.                  if(key4==0)
  194.                             {
  195.                               delay(5);
  196.                               if(key4==0)
  197.                                {
  198.                                  while(!key4)                                                                          //松手检测
  199.                                             {
  200.                                               display_process();                                              //调用显示处理函数
  201.                           display(shi,ge,shifen,baifen);    //调用显示函数
  202.                                             }
  203.                                           TR0=0;
  204.                                           i++;
  205.                                           if(i==11)
  206.                                             i=1;
  207.                                           data_read();
  208.                                }
  209.                             }
  210.                  if(key5==0)
  211.                             {
  212.                               delay(5);
  213.                               if(key5==0)
  214.                                {
  215.                                  while(!key5)                                                                          //松手检测
  216.                                             {
  217.                                               display_process();                                              //调用显示处理函数
  218.                           display(shi,ge,shifen,baifen);    //调用显示函数
  219.                                             }
  220.                                           flag_CLR=~flag_CLR;
  221.                                }
  222.                             }
  223. }                           

  225. void display_process()                                  //显示处理函数
  226. {
  227.   shifen=aa%100/10;                                                                                    //正常走秒的处理
  228.   baifen=aa%10;
  229.   shi=temp%100/10;
  230.   ge=temp%10;
  231.   if(flag_mode==1&&num!=0&&flag_2sec==0)              //间隔2秒停顿的处理
  232.    {
  233.               shi=time_data2[num]/10;
  234.      ge=time_data2[num]%10;
  235.               shifen=time_data1[num]/10;
  236.               baifen=time_data1[num]%10;
  237.               if(temp-time_data2[num]==2)
  238.                  flag_2sec=~flag_2sec;
  239.    }
  240.   if(i!=0)                                                                                                                    //查看存储数据的处理
  241.               {
  242.                 shi=time_data2[i]/10;
  243.                 ge=time_data2[i]%10;
  244.                 shifen=time_data1[i]/10;
  245.                 baifen=time_data1[i]%10;
  246.     }
  247. }

  249. void timer0() interrupt 1                      //定时器T0中断服务函数
  250. {
  251.               TH0=(65536-10000)/256;   //重新赋初值
  252.               TL0=(65536-10000)%256;
  253.               aa++;                    //中断一次10ms变量aa的值加1
  254.               if(aa==100)              //中断100次后，定时时间100*10ms=1000ms=1s，变量temp的值加1
  255.               {
  256.                 aa=0;
  257.                 temp++;
  258.                 if(temp==100)          //秒表到达100s后回零
  259.                             temp=0;
  260.               }            
  261. }

  263. /* EEPROM存储器操作函数 */
  264. /* ================================= */
  265. void ISP_IAP_enable(void)
  266. {
  267. EA = 0;     
  268. ISP_CONTR = ISP_CONTR & 0x18;      
  269. ISP_CONTR = ISP_CONTR | WaitTime;
  270. ISP_CONTR = ISP_CONTR | 0x80;      
  271. }
  272. /* ================================= */
  273. void ISP_IAP_disable(void)
  274. {
  275. ISP_CONTR=ISP_CONTR&0x7f;
  276. ISP_TRIG=0x00;
  277. EA=1;  
  278. }
  279. /* ==================================== */
  280. void ISPgoon(void)
  281. {
  282. ISP_IAP_enable();  
  283. ISP_TRIG = 0x46;
  284. ISP_TRIG = 0xb9;
  285. _nop_();
  286. }
  287. /* ============================================ */
  288. uchar byte_read(uint byte_addr)
  289. {
  290. ISP_ADDRH = (uchar)(byte_addr >> 8);
  291. ISP_ADDRL = (uchar)(byte_addr & 0x00ff);
  292. ISP_CMD   = ISP_CMD & 0xf8;  
  293. ISP_CMD   = ISP_CMD | RdCommand;
  294. ISPgoon();      
  295. ISP_IAP_disable();  
  296. return (ISP_DATA);  
  297. }
  298. /* ========================================== */
  299. void SectorErase(uint sector_addr)
  300. {
  301. uint iSectorAddr;
  302. iSectorAddr = (sector_addr & 0xfe00);
  303. ISP_ADDRH   = (uchar)(iSectorAddr >> 8);
  304. ISP_ADDRL   = 0x00;
  305. ISP_CMD     = ISP_CMD & 0xf8;  
  306. ISP_CMD     = ISP_CMD | EraseCommand;
  307. ISPgoon();      
  308. ISP_IAP_disable();  
  309. }
  310. /* ============================================ */
  311. void byte_write(uint byte_addr, uchar original_data)
  312. {
  313. ISP_ADDRH = (uchar)(byte_addr >> 8);
  314. ISP_ADDRL = (uchar)(byte_addr & 0x00ff);
  315. ISP_CMD   = ISP_CMD & 0xf8;   
  316. ISP_CMD   = ISP_CMD | PrgCommand;
  317. ISP_DATA  = original_data;
  318. ISPgoon();     
  319. ISP_IAP_disable();   
  320. }

  322. void data_read()                                                                      //读数组数据函数
  323. {
  324.   aa=time_data1[i];
  325.   temp=time_data2[i];
  326. }

  328. void memory_write()                                                                        //写EEPROM数据函数
  329. {
  330.   aa1=aa;
  331.   temp1=temp;
  332.   time_data1[num]=aa1;
  333.   time_data2[num]=temp1;
  334.   if(num==1)
  335.     SectorErase(0x2000);              //擦除扇区
  336.   byte_write(0x2000+num,aa1);         //重新写入数据
  337.   byte_write(0x2000+num+10,temp1);    //重新写入数据   
  338.   flag_2sec=0;


  341. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码


完整论文下载（word格式 可编辑）还带仿真和源码：



评分

参与人数 1黑币 +10 收起 理由
话梅 + 10 很给力！

查看全部评分

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏4 分享淘帖 顶顶1 踩踩
回复

使用道具 举报

沙发
ID:569720 发表于 2019-6-22 21:25 | 只看该作者
厉害，很有用，收获很多
回复

使用道具 举报

板凳
ID:757221 发表于 2020-6-17 15:26 | 只看该作者
作者说的模式二，大家知道怎么运行吗？
回复

使用道具 举报

地板
ID:757221 发表于 2020-6-17 15:31 | 只看该作者
作者说的模式二，大家有知道怎么运行的吗？
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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