新闻中心

EEPW首页 > 嵌入式系统 > 设计应用 > 第89节：用单片机内部定时器做一个时钟

第89节：用单片机内部定时器做一个时钟

作者： 时间：2016-11-22 来源：网络
收藏
开场白：
很多网友建议，为了方便初学者学习编程思路，我应该用单片机定时器做一个时钟程序供大家参考学习。其实我前面第48节就已经用ds1302做了一个可以显示和更高时间的时钟，这一节只要在第48节的源代码基础上，大的框架不用动，只需要把ds1302产生的时间改成用定时中断产生的时间就可以了，改动的地方非常小。但是为了让时间的精度更高，最后必须跟标准时间进行校验，来修正系统中一秒钟需要多个定时中断的误差，这个误差决定了系统的时间精度，其实这个校验方法我在前面很多章节上跟大家介绍过了：
第一步：在程序代码上先写入1秒钟大概需要200个定时中断。
第二步：把程序烧录进单片机后，上电开始测试，手上同步打开手机里的秒表，当手机的标准时间跑了780秒(这个标准时间跑得越长校验精度越高)，而此时单片机仅仅跑了1632秒。那么最终得出1秒钟需要的定时中断次数是:const_time_1s=(200*1632)/780=418。
第三步：如果发现时钟还是不太准，可以继续返回第一步根据最新1秒钟的时间是418次，多校验几次，来不断调整const_time_1s的数值，直到找到相对精度的时间为止。
本系统仅供学习，精度不可能做得很好，因为影响时间精度的因素还有定时中断的重装值，定时中断里面的代码尽量少，以及晶振等不好控制的因素。所以鸿哥一直不推荐在实际项目中用单片机的内部定时器做实时时钟，因为精度有限。真正想要准确的时钟时间，还是强烈建议大家用外部专用的时钟芯片或者用CPLD/FPGA来做。
具体内容，请看源代码讲解。
（1硬件平台.
基于朱兆祺51单片机学习板。
（2）实现功能：
本程序有2两个窗口。
第1个窗口显示日期。显示格式“年-月-日”。注意中间有“-”分开。
第2个窗口显示时间。显示格式“时 分 秒”。注意中间没“-”，只有空格分开。
系统上电后，默认显示第2个窗口，实时显示动态的“时 分 秒”时间。此时按下S13按键不松手就会切换到显示日期的第1个窗口。松手后自动切换回第2个显示动态时间的窗口。
需要更改时间的时候，长按S9按键不松手超过3秒后，系统将进入修改时间的状态，切换到第1个日期窗口，并且显示“年”的两位数码管会闪烁，此时可以按S1或者S5加减按键修改年的参数，修改完年后，继续短按S9按键，会切换到“月”的参数闪烁状态，只要依次不断按下S9按键，就会依次切换年，月，日，时，分，秒的参数闪烁状态，最后修改完秒的参数后，系统会自动把我们修改设置的日期时间一次性更改到定时中断函数内部的时间变量，达到修改日期时间的目的。
S13是电平变化按键，用来切换窗口的，专门用来查看当前日期。按下S13按键时显示日期窗口，松手后返回到显示实时时间的窗口。
[size=10.5000pt]（3）源代码讲解如下：
  1. #include "REG52.H"
  3. #define const_dpy_time_half200//数码管闪烁时间的半值
  4. #define const_dpy_time_all 400//数码管闪烁时间的全值 一定要比const_dpy_time_half 大
  6. #define const_voice_short40 //蜂鸣器短叫的持续时间
  7. #define const_key_time120 //按键去抖动延时的时间
  8. #define const_key_time220 //按键去抖动延时的时间
  9. #define const_key_time320 //按键去抖动延时的时间
  10. #define const_key_time420 //按键去抖动延时的时间
  12. #define const_key_time171200//长按超过3秒的时间
  15. /* 注释一：
  16. * const_timer_1s这个是产生多少次定时中断才算1秒钟的标准。这个标准决定了时钟的精度。这个标准最后是需要校验的。
  17. * 那么是如何检验的呢？根据我们前面介绍的校验时间方法：
  18. * 步骤：
  19. * 第一步：在程序代码上先写入1秒钟大概需要200个定时中断。
  20. * 第二步：把程序烧录进单片机后，上电开始测试，手上同步打开手机里的秒表，当手机的标准时间跑了780秒(这个标准时间跑得越长校验精度越高)，
  21. * 而此时单片机仅仅跑了1632秒。那么最终得出1秒钟需要的定时中断次数是:const_time_1s=(200*1632)/780=418。
  22. * 第三步：如果发现时钟还是不太准，可以继续返回第一步根据最新1秒钟的时间是418次，多校验几次。本系统仅供学习，精度不可能做得很好，因为
  23. * 影响时间精度的因素还有定时中断的重装值，定时中断里面的代码尽量少，以及晶振等不好控制的因素。所以鸿哥一直不推荐在实际项目中
  24. * 用单片机的内部定时器做实时时钟，因为精度有限。真正想要准确的时钟时间，还是强烈建议大家用外部专用的时钟芯片或者用CPLD/FPGA来做。
  25. */
  28. //#define const_timer_1s200 //第一次假设大概1秒的时间需要200个定时中断
  30. #define const_timer_1s418//第二次校验后，最终选定大概1秒的时间需要418个定时中断。如果发现时间还是不准，可以在此基础上继续校验来调整此数据。
  32. void initial_myself(void);
  33. void initial_peripheral(void);
  34. void delay_short(unsigned int uiDelayShort);
  35. void delay_long(unsigned int uiDelaylong);
  38. //驱动数码管的74HC595
  39. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
  40. void display_drive(void); //显示数码管字模的驱动函数
  41. void display_service(void); //显示的窗口菜单服务程序
  42. //驱动LED的74HC595
  43. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
  45. void T0_time(void);//定时中断函数
  47. void key_service(void); //按键服务的应用程序
  48. void key_scan(void);//按键扫描函数 放在定时中断里
  50. void timer_sampling(void); //定时器采样程序，内部每秒钟采集更新一次
  53. unsigned char get_date(unsigned char ucYearTemp,unsigned char ucMonthTemp);//获取当前月份的最大天数
  55. //日调整 每个月份的日最大取值不同，有的最大28日，有的最大29日，有的最大30，有的最大31
  56. unsigned char date_adjust(unsigned char ucYearTemp,unsigned char ucMonthTemp,unsigned char ucDateTemp); //日调整
  59. sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
  60. sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
  61. sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
  62. sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
  64. sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
  65. sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
  67. sbit dig_hc595_sh_dr=P2^0; //数码管的74HC595程序
  68. sbit dig_hc595_st_dr=P2^1;
  69. sbit dig_hc595_ds_dr=P2^2;
  70. sbit hc595_sh_dr=P2^3; //LED灯的74HC595程序
  71. sbit hc595_st_dr=P2^4;
  72. sbit hc595_ds_dr=P2^5;
  74. unsigned char ucKeySec=0; //被触发的按键编号
  76. unsigned intuiKeyTimeCnt1=0; //按键去抖动延时计数器
  77. unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
  78. unsigned intuiKeyTimeCnt2=0; //按键去抖动延时计数器
  79. unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
  80. unsigned intuiKeyTimeCnt3=0; //按键去抖动延时计数器
  81. unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
  83. unsigned int uiKey4Cnt1=0;//在软件滤波中，用到的变量
  84. unsigned int uiKey4Cnt2=0;
  85. unsigned char ucKey4Sr=1;//实时反映按键的电平状态
  86. unsigned char ucKey4SrRecord=0; //记录上一次按键的电平状态
  88. unsigned intuiVoiceCnt=0;//蜂鸣器鸣叫的持续时间计数器
  89. unsigned charucVoiceLock=0;//蜂鸣器鸣叫的原子锁
  91. unsigned char ucDigShow8;//第8位数码管要显示的内容
  92. unsigned char ucDigShow7;//第7位数码管要显示的内容
  93. unsigned char ucDigShow6;//第6位数码管要显示的内容
  94. unsigned char ucDigShow5;//第5位数码管要显示的内容
  95. unsigned char ucDigShow4;//第4位数码管要显示的内容
  96. unsigned char ucDigShow3;//第3位数码管要显示的内容
  97. unsigned char ucDigShow2;//第2位数码管要显示的内容
  98. unsigned char ucDigShow1;//第1位数码管要显示的内容
  100. unsigned char ucDigDot8;//数码管8的小数点是否显示的标志
  101. unsigned char ucDigDot7;//数码管7的小数点是否显示的标志
  102. unsigned char ucDigDot6;//数码管6的小数点是否显示的标志
  103. unsigned char ucDigDot5;//数码管5的小数点是否显示的标志
  104. unsigned char ucDigDot4;//数码管4的小数点是否显示的标志
  105. unsigned char ucDigDot3;//数码管3的小数点是否显示的标志
  106. unsigned char ucDigDot2;//数码管2的小数点是否显示的标志
  107. unsigned char ucDigDot1;//数码管1的小数点是否显示的标志
  108. unsigned char ucDigShowTemp=0; //临时中间变量
  109. unsigned char ucDisplayDriveStep=1;//动态扫描数码管的步骤变量
  112. unsigned char ucWd=2;//本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  113. unsigned char ucPart=0;//本程序的核心变量，局部显示变量。类似于二级菜单的变量。代表显示不同的局部。
  115. unsigned char ucWd1Update=0; //窗口1更新显示标志
  116. unsigned char ucWd2Update=1; //窗口2更新显示标志
  118. unsigned char ucWd1Part1Update=0;//在窗口1中，局部1的更新显示标志
  119. unsigned char ucWd1Part2Update=0; //在窗口1中，局部2的更新显示标志
  120. unsigned char ucWd1Part3Update=0; //在窗口1中，局部3的更新显示标志
  122. unsigned char ucWd2Part1Update=0;//在窗口2中，局部1的更新显示标志
  123. unsigned char ucWd2Part2Update=0; //在窗口2中，局部2的更新显示标志
  124. unsigned char ucWd2Part3Update=0; //在窗口2中，局部3的更新显示标志
  126. unsigned charucYear=15; //用来显示和设置的时间变量
  127. unsigned charucMonth=1;
  128. unsigned charucDate=1;
  129. unsigned charucHour=12;
  130. unsigned charucMinute=0;
  131. unsigned charucSecond=0;
  134. unsigned int uiTimerCnt=0; //计时器的时基
  136. unsigned charucTimerYear=15; //在定时器内部时基产生的时间变量
  137. unsigned charucTimerMonth=1;
  138. unsigned charucTimerDate=1;
  139. unsigned charucTimerHour=12;
  140. unsigned charucTimerMinute=0;
  141. unsigned charucTimerSecond=0;
  143. unsigned charucTimerDateMax=31; //当前月份的最大天数
  145. unsigned charucTimerUpdate=0; //定时器每1秒钟所产生的标志
  146. unsigned charucTimerStart=1;//是否打开定时器内部时间的标志，在本程序相当于原子锁的作用。
  148. unsigned char ucTemp1=0;//中间过渡变量
  149. unsigned char ucTemp2=0;//中间过渡变量
  151. unsigned char ucTemp4=0;//中间过渡变量
  152. unsigned char ucTemp5=0;//中间过渡变量
  154. unsigned char ucTemp7=0;//中间过渡变量
  155. unsigned char ucTemp8=0;//中间过渡变量
  157. unsigned char ucDelayTimerLock=0; //原子锁
  158. unsigned intuiDelayTimer=0;
  161. unsigned char ucDpyTimeLock=0; //原子锁
  162. unsigned intuiDpyTimeCnt=0;//数码管的闪烁计时器,放在定时中断里不断累加
  164. //根据原理图得出的共阴数码管字模表
  165. code unsigned char dig_table[]=
  166. {
  167. 0x3f,//0 序号0
  168. 0x06,//1 序号1
  169. 0x5b,//2 序号2
  170. 0x4f,//3 序号3
  171. 0x66,//4 序号4
  172. 0x6d,//5 序号5
  173. 0x7d,//6 序号6
  174. 0x07,//7 序号7
  175. 0x7f,//8 序号8
  176. 0x6f,//9 序号9
  177. 0x00,//无 序号10
  178. 0x40,//- 序号11
  179. 0x73,//P 序号12
  180. };
  181. void main()
  182. {
  183. initial_myself();
  184. delay_long(100);
  185. initial_peripheral();
  186. while(1)
  187. {
  188. key_service(); //按键服务的应用程序
  189. timer_sampling(); //定时器采样程序，内部每秒钟采集更新一次
  190. display_service(); //显示的窗口菜单服务程序
  191. }
  192. }
  195. /* 注释二：
  196. * 系统不用时时刻刻采集定时器的内部数据，每隔1秒钟的时间更新采集一次就可以了。
  197. * 这个1秒钟的时间是根据定时器内部ucTimerUpdate变量来判断。
  198. */
  199. void timer_sampling(void) //采样定时器的程序，内部每秒钟采集更新一次
  200. {
  201. if(ucPart==0)//当系统不是处于设置日期和时间的情况下
  202. {
  203. if(ucTimerUpdate==1)//每隔1秒钟时间就更新采集一次定时器的时间数据
  204. {
  205. ucTimerUpdate=0;//及时清零，避免一直更新。
  207. ucYear=ucTimerYear; //读取定时器内部的年
  208. ucMonth=ucTimerMonth; //读取定时器内部的月
  209. ucDate=ucTimerDate;//读取定时器内部的日
  210. ucHour=ucTimerHour; //读取定时器内部的时
  211. ucMinute=ucTimerMinute;//读取定时器内部的分
  212. ucSecond=ucTimerSecond;//读取定时器内部的秒
  214. ucWd2Update=1; //窗口2更新显示时间
  215. }
  217. }
  218. }
  220. /* 注释三：
  221. * 根据年份和月份来获取当前这个月的最大天数。每个月份的天数最大取值不同，有的最大28日，
  222. * 有的最大29日，有的最大30，有的最大31。
  223. */
  224. unsigned char get_date(unsigned char ucYearTemp,unsigned char ucMonthTemp)
  225. {
  228. unsigned char ucDayResult;
  229. unsigned int uiYearTemp;
  230. unsigned int uiYearYu;
  232. ucDayResult=31; //默认最大是31天，以下根据不同的年份和月份来决定是否需要修正这个值
  234. switch(ucMonthTemp)//根据不同的月份来获取当前月份天数的最大值
  235. {
  236. case 2://二月份要计算是否是闰年
  237. uiYearTemp=2000+ucYearTemp;
  238. uiYearYu=uiYearTemp%4;
  239. if(uiYearYu==0) //闰年
  240. {
  241. ucDayResult=29;
  242. }
  243. else
  244. {
  245. ucDayResult=28;
  246. }
  247. break;
  248. case 4:
  249. case 6:
  250. case 9:
  251. case 11:
  252. ucDayResult=30;
  253. break;
  255. }
  257. return ucDayResult;
  259. }
  261. //日调整 每个月份的日最大取值不同，有的最大28日，有的最大29日，有的最大30，有的最大31
  262. unsigned char date_adjust(unsigned char ucYearTemp,unsigned char ucMonthTemp,unsigned char ucDateTemp) //日调整
  263. {
  266. unsigned char ucDayResult;
  267. unsigned int uiYearTemp;
  268. unsigned int uiYearYu;
  271. ucDayResult=ucDateTemp;
  273. switch(ucMonthTemp)//根据不同的月份来修正不同的日最大值
  274. {
  275. case 2://二月份要计算是否是闰年
  276. uiYearTemp=2000+ucYearTemp;
  277. uiYearYu=uiYearTemp%4;
  278. if(uiYearYu==0) //闰年
  279. {
  280. if(ucDayResult>29)
  281. {
  282. ucDayResult=29;
  283. }
  284. }
  285. else
  286. {
  287. if(ucDayResult>28)
  288. {
  289. ucDayResult=28;
  290. }
  291. }
  292. break;
  293. case 4:
  294. case 6:
  295. case 9:
  296. case 11:
  297. if(ucDayResult>30)
  298. {
  299. ucDayResult=30;
  300. }
  301. break;
  303. }
  305. return ucDayResult;
  307. }
  310. void display_service(void) //显示的窗口菜单服务程序
  311. {
  313. switch(ucWd)//本程序的核心变量，窗口显示变量。类似于一级菜单的变量。代表显示不同的窗口。
  314. {
  315. case 1: //显示日期窗口的数据数据格式 NN-YY-RR 年-月-日
  316. if(ucWd1Update==1)//窗口1要全部更新显示
  317. {
  318. ucWd1Update=0;//及时清零标志，避免一直进来扫描
  320. ucDigShow6=11;//显示一杠"-"
  321. ucDigShow3=11;//显示一杠"-"
  323. ucWd1Part1Update=1;//局部年更新显示
  324. ucWd1Part2Update=1;//局部月更新显示
  325. ucWd1Part3Update=1;//局部日更新显示
  326. }
  328. if(ucWd1Part1Update==1)//局部年更新显示
  329. {
  330. ucWd1Part1Update=0;
  331. ucTemp8=ucYear/10;//年
  332. ucTemp7=ucYear%10;
  334. ucDigShow8=ucTemp8; //数码管显示实际内容
  335. ucDigShow7=ucTemp7;
  336. }
  339. if(ucWd1Part2Update==1)//局部月更新显示
  340. {
  341. ucWd1Part2Update=0;
  342. ucTemp5=ucMonth/10;//月
  343. ucTemp4=ucMonth%10;
  345. ucDigShow5=ucTemp5; //数码管显示实际内容
  346. ucDigShow4=ucTemp4;
  347. }
  350. if(ucWd1Part3Update==1) //局部日更新显示
  351. {
  352. ucWd1Part3Update=0;
  353. ucTemp2=ucDate/10;//日
  354. ucTemp1=ucDate%10;
  356. ucDigShow2=ucTemp2; //数码管显示实际内容
  357. ucDigShow1=ucTemp1;
  358. }
  359. //数码管闪烁
  360. switch(ucPart)//相当于二级菜单，根据局部变量的值，使对应的参数产生闪烁的动态效果。
  361. {
  362. case 0://都不闪烁
  363. break;
  364. case 1://年参数闪烁
  365. if(uiDpyTimeCnt==const_dpy_time_half)
  366. {
  367. ucDigShow8=ucTemp8; //数码管显示实际内容
  368. ucDigShow7=ucTemp7;
  369. }
  370. else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
  371. {
  372. ucDpyTimeLock=1; //原子锁加锁
  373. uiDpyTimeCnt=0; //及时把闪烁记时器清零
  374. ucDpyTimeLock=0;//原子锁解锁
  376. ucDigShow8=10; //数码管显示空，什么都不显示
  377. ucDigShow7=10;
  379. }
  380. break;
  381. case 2: //月参数闪烁
  382. if(uiDpyTimeCnt==const_dpy_time_half)
  383. {
  384. ucDigShow5=ucTemp5; //数码管显示实际内容
  385. ucDigShow4=ucTemp4;
  386. }
  387. else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
  388. {
  389. ucDpyTimeLock=1; //原子锁加锁
  390. uiDpyTimeCnt=0; //及时把闪烁记时器清零
  391. ucDpyTimeLock=0;//原子锁解锁
  393. ucDigShow5=10; //数码管显示空，什么都不显示
  394. ucDigShow4=10;
  396. }
  397. break;
  398. case 3: //日参数闪烁
  399. if(uiDpyTimeCnt==const_dpy_time_half)
  400. {
  401. ucDigShow2=ucTemp2; //数码管显示实际内容
  402. ucDigShow1=ucTemp1;
  403. }
  404. else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
  405. {
  406. ucDpyTimeLock=1; //原子锁加锁
  407. uiDpyTimeCnt=0; //及时把闪烁记时器清零
  408. ucDpyTimeLock=0;//原子锁解锁
  410. ucDigShow2=10; //数码管显示空，什么都不显示
  411. ucDigShow1=10;
  413. }
  414. break;
  415. }
  417. break;
  418. case 2: //显示时间窗口的数据数据格式 SS FF MM 时 分 秒
  419. if(ucWd2Update==1)//窗口2要全部更新显示
  420. {
  421. ucWd2Update=0;//及时清零标志，避免一直进来扫描
  423. ucDigShow6=10;//显示空
  424. ucDigShow3=10;//显示空
  426. ucWd2Part3Update=1;//局部时更新显示
  427. ucWd2Part2Update=1;//局部分更新显示
  428. ucWd2Part1Update=1;//局部秒更新显示
  429. }
  431. if(ucWd2Part1Update==1)//局部时更新显示
  432. {
  433. ucWd2Part1Update=0;
  434. ucTemp8=ucHour/10;//时
  435. ucTemp7=ucHour%10;
  437. ucDigShow8=ucTemp8; //数码管显示实际内容
  438. ucDigShow7=ucTemp7;
  439. }
  442. if(ucWd2Part2Update==1)//局部分更新显示
  443. {
  444. ucWd2Part2Update=0;
  445. ucTemp5=ucMinute/10;//分
  446. ucTemp4=ucMinute%10;
  448. ucDigShow5=ucTemp5; //数码管显示实际内容
  449. ucDigShow4=ucTemp4;
  450. }
  453. if(ucWd2Part3Update==1) //局部秒更新显示
  454. {
  455. ucWd2Part3Update=0;
  456. ucTemp2=ucSecond/10;//秒
  457. ucTemp1=ucSecond%10;
  459. ucDigShow2=ucTemp2; //数码管显示实际内容
  460. ucDigShow1=ucTemp1;
  461. }
  462. //数码管闪烁
  463. switch(ucPart)//相当于二级菜单，根据局部变量的值，使对应的参数产生闪烁的动态效果。
  464. {
  465. case 0://都不闪烁
  466. break;
  467. case 1://时参数闪烁
  468. if(uiDpyTimeCnt==const_dpy_time_half)
  469. {
  470. ucDigShow8=ucTemp8; //数码管显示实际内容
  471. ucDigShow7=ucTemp7;
  472. }
  473. else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
  474. {
  475. ucDpyTimeLock=1; //原子锁加锁
  476. uiDpyTimeCnt=0; //及时把闪烁记时器清零
  477. ucDpyTimeLock=0;//原子锁解锁
  479. ucDigShow8=10; //数码管显示空，什么都不显示
  480. ucDigShow7=10;
  482. }
  483. break;
  484. case 2: //分参数闪烁
  485. if(uiDpyTimeCnt==const_dpy_time_half)
  486. {
  487. ucDigShow5=ucTemp5; //数码管显示实际内容
  488. ucDigShow4=ucTemp4;
  489. }
  490. else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
  491. {
  492. ucDpyTimeLock=1; //原子锁加锁
  493. uiDpyTimeCnt=0; //及时把闪烁记时器清零
  494. ucDpyTimeLock=0;//原子锁解锁
  496. ucDigShow5=10; //数码管显示空，什么都不显示
  497. ucDigShow4=10;
  499. }
  500. break;
  501. case 3: //秒参数闪烁
  502. if(uiDpyTimeCnt==const_dpy_time_half)
  503. {
  504. ucDigShow2=ucTemp2; //数码管显示实际内容
  505. ucDigShow1=ucTemp1;
  506. }
  507. else if(uiDpyTimeCnt>const_dpy_time_all) //const_dpy_time_all一定要比const_dpy_time_half 大
  508. {
  509. ucDpyTimeLock=1; //原子锁加锁
  510. uiDpyTimeCnt=0; //及时把闪烁记时器清零
  511. ucDpyTimeLock=0;//原子锁解锁
  513. ucDigShow2=10; //数码管显示空，什么都不显示
  514. ucDigShow1=10;
  516. }
  517. break;
  518. }
  521. break;
  522. }
  525. }
  527. void key_scan(void)//按键扫描函数 放在定时中断里
  528. {
  529. if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  530. {
  531. ucKeyLock1=0; //按键自锁标志清零
  532. uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
  533. }
  534. else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
  535. {
  536. uiKeyTimeCnt1++; //累加定时中断次数
  537. if(uiKeyTimeCnt1>const_key_time1)
  538. {
  539. uiKeyTimeCnt1=0;
  540. ucKeyLock1=1;//自锁按键置位,避免一直触发
  541. ucKeySec=1; //触发1号键
  542. }
  543. }
  545. if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  546. {
  547. ucKeyLock2=0; //按键自锁标志清零
  548. uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
  549. }
  550. else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
  551. {
  552. uiKeyTimeCnt2++; //累加定时中断次数
  553. if(uiKeyTimeCnt2>const_key_time2)
  554. {
  555. uiKeyTimeCnt2=0;
  556. ucKeyLock2=1;//自锁按键置位,避免一直触发
  557. ucKeySec=2; //触发2号键
  558. }
  559. }
  563. /* 注释四：
  564. * 注意，此处把一个按键的短按和长按的功能都实现了。
  565. */
  567. if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
  568. {
  569. ucKeyLock3=0; //按键自锁标志清零
  570. uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
  571. }
  572. else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
  573. {
  574. uiKeyTimeCnt3++; //累加定时中断次数
  575. if(uiKeyTimeCnt3>const_key_time3)
  576. {
  577. uiKeyTimeCnt3=0;
  578. ucKeyLock3=1;//自锁按键置位,避免一直触发
  579. ucKeySec=3; //短按触发3号键
  580. }
  581. }
  582. else if(uiKeyTimeCnt3
  583. {
  584. uiKeyTimeCnt3++; //累加定时中断次数
  585. if(uiKeyTimeCnt3==const_key_time17)//等于3秒钟，触发17号长按按键
  586. {
  587. ucKeySec=17; //长按3秒触发17号键
  588. }
  589. }
  592. /* 注释五：
  593. * 注意，此处是电平按键的滤波抗干扰处理
  594. */
  595. if(key_sr4==1)//对应朱兆祺学习板的S13键
  596. {
  597. uiKey4Cnt1=0; //在软件滤波中，非常关键的语句！！！类似按键去抖动程序的及时清零
  598. uiKey4Cnt2++; //类似独立按键去抖动的软件抗干扰处理
  599. if(uiKey4Cnt2>const_key_time4)
  600. {
  601. uiKey4Cnt2=0;
  602. ucKey4Sr=1;//实时反映按键松手时的电平状态
  603. }
  604. }
  605. else
  606. {
  607. uiKey4Cnt2=0; //在软件滤波中，非常关键的语句！！！类似按键去抖动程序的及时清零
  608. uiKey4Cnt1++;
  609. if(uiKey4Cnt1>const_key_time4)
  610. {
  611. uiKey4Cnt1=0;
  612. ucKey4Sr=0;//实时反映按键按下时的电平状态
  613. }
  614. }
  617. }
  619. void key_service(void) //按键服务的应用程序
  620. {
  622. switch(ucKeySec) //按键服务状态切换
  623. {
  624. case 1:// 加按键 对应朱兆祺学习板的S1键
  625. switch(ucWd)//在不同的窗口下，设置不同的参数
  626. {
  627. case 1:
  628. switch(ucPart) //在不同的局部变量下，相当于二级菜单
  629. {
  630. case 1://年
  631. ucYear++;
  632. if(ucYear>99)
  633. {
  634. ucYear=99;
  635. }
  636. ucWd1Part1Update=1;//更新显示
  637. break;
  638. case 2: //月
  639. ucMonth++;
  640. if(ucMonth>12)
  641. {
  642. ucMonth=12;
  643. }
  644. ucWd1Part2Update=1;//更新显示
  645. break;
  646. case 3: //日
  647. ucDate++;
  648. if(ucDate>31)
  649. {
  650. ucDate=31;
  651. }
  652. ucWd1Part3Update=1;//更新显示
  653. break;
  655. }
  658. break;
  659. case 2:
  660. switch(ucPart) //在不同的局部变量下，相当于二级菜单
  661. {
  662. case 1://时
  663. ucHour++;
  664. if(ucHour>23)
  665. {
  666. ucHour=23;
  667. }
  668. ucWd2Part1Update=1;//更新显示
  669. break;
  670. case 2: //分
  671. ucMinute++;
  672. if(ucMinute>59)
  673. {
  674. ucMinute=59;
  675. }
  676. ucWd2Part2Update=1;//更新显示
  677. break;
  678. case 3: //秒
  679. ucSecond++;
  680. if(ucSecond>59)
  681. {
  682. ucSecond=59;
  683. }
  684. ucWd2Part3Update=1;//更新显示
  685. break;
  687. }
  688. break;
  690. }
  692. ucVoiceLock=1;//原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
  693. uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  694. ucVoiceLock=0;//原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
  696. ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
  697. break;
  699. case 2:// 减按键 对应朱兆祺学习板的S5键
  700. switch(ucWd)//在不同的窗口下，设置不同的参数
  701. {
  702. case 1:
  703. switch(ucPart) //在不同的局部变量下，相当于二级菜单
  704. {
  705. case 1://年
  706. ucYear--;
  707. if(ucYear>99)
  708. {
  709. ucYear=0;
  710. }
  711. ucWd1Part1Update=1;//更新显示
  712. break;
  713. case 2: //月
  714. ucMonth--;
  715. if(ucMonth<1)
  716. {
  717. ucMonth=1;
  718. }
  719. ucWd1Part2Update=1;//更新显示
  720. break;
  721. case 3: //日
  722. ucDate--;
  723. if(ucDate<1)
  724. {
  725. ucDate=1;
  726. }
  727. ucWd1Part3Update=1;//更新显示
  728. break;
  730. }
  733. break;
  734. case 2:
  735. switch(ucPart) //在不同的局部变量下，相当于二级菜单
  736. {
  737. case 1://时
  738. ucHour--;
  739. if(ucHour>23)
  740. {
  741. ucHour=0;
  742. }
  743. ucWd2Part1Update=1;//更新显示
  744. break;
  745. case 2: //分
  746. ucMinute--;
  747. if(ucMinute>59)
  748. {
  749. ucMinute=0;
  750. }
  751. ucWd2Part2Update=1;//更新显示
  752. break;
  753. case 3: //秒
  754. ucSecond--;
  755. if(ucSecond>59)
  756. {
  757. ucSecond=0;
  758. }
  759. ucWd2Part3Update=1;//更新显示
  760. break;
  762. }
  763. break;
  765. }
  767. ucVoiceLock=1;//原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
  768. uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  769. ucVoiceLock=0;//原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
  771. ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
  772. break;
  774. case 3://短按设置按键 对应朱兆祺学习板的S9键
  775. switch(ucWd)//在不同的窗口下，设置不同的参数
  776. {
  777. case 1:
  778. ucPart++;
  779. if(ucPart>3)
  780. {
  781. ucPart=1;
  782. ucWd=2; //切换到第二个窗口，设置时分秒
  783. ucWd2Update=1;//窗口2更新显示
  784. }
  785. ucWd1Update=1;//窗口1更新显示
  786. break;
  787. case 2:
  788. if(ucPart>0) //在窗口2的时候，要第一次激活设置时间，必须是长按3秒才可以，这里短按激活不了第一次
  789. {
  790. ucPart++;
  791. if(ucPart>3)//设置时间结束
  792. {
  793. ucPart=0;
  797. /* 注释六：
  798. * 每个月份的天数最大值是不一样的，在写入ds1302时钟芯片内部数据前，应该做一次调整。
  799. * 有的月份最大28天，有的月份最大29天，有的月份最大30天，有的月份最大31天，
  800. */
  801. ucDate=date_adjust(ucYear,ucMonth,ucDate); //日调整 避免日的数值在某个月份超范围
  803. ucTimerStart=0;//关闭定时器的时间。在更改定时器内部时间数据时，先关闭它，相当于原子锁的加锁作用。
  805. ucTimerYear=ucYear;//把设置和显示的数据更改到定时器内部的时间变量
  806. ucTimerMonth=ucMonth;
  807. ucTimerDate=ucDate;
  808. ucTimerHour=ucHour;
  809. ucTimerMinute=ucMinute;
  810. ucTimerSecond=ucSecond;
  812. ucTimerStart=1;//打开定时器的时间。在更改定时器内部时间数据后，再打开它，相当于原子锁的解锁作用。
  814. }
  815. ucWd2Update=1;//窗口2更新显示
  816. }
  818. break;
  820. }
  823. ucVoiceLock=1;//原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
  824. uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  825. ucVoiceLock=0;//原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
  827. ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
  828. break;
  829. case 17://长按3秒设置按键 对应朱兆祺学习板的S9键
  830. switch(ucWd)//在不同的窗口下，设置不同的参数
  831. {
  832. case 2:
  833. if(ucPart==0) //处于非设置时间的状态下，要第一次激活设置时间，必须是长按3秒才可以
  834. {
  835. ucWd=1;
  836. ucPart=1;//进入到设置日期的状态下
  837. ucWd1Update=1;//窗口1更新显示
  838. }
  839. break;
  841. }
  842. ucVoiceLock=1;//原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
  843. uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
  844. ucVoiceLock=0;//原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
  846. ucKeySec=0;//响应按键服务处理程序后，按键编号清零，避免一致触发
  847. break;
  849. }
  852. /* 注释七：
  853. * 注意，此处就是第一次出现的电平按键程序，跟以往的下降沿按键不一样。
  854. * ucKey4Sr是经过软件滤波处理后，直接反应IO口电平状态的变量.当电平发生
  855. * 变化时，就会切换到不同的显示界面，这里多用了一个ucKey4SrRecord变量
  856. * 记录上一次的电平状态，是为了避免一直刷新显示。
  857. */
  858. if(ucKey4Sr!=ucKey4SrRecord)//说明S13的切换按键电平状态发生变化
  859. {
  860. ucKey4SrRecord=ucKey4Sr;//及时记录当前最新的按键电平状态避免一直进来触发
  862. if(ucKey4Sr==1) //松手后切换到显示时间的窗口
  863. {
  864. ucWd=2; //显示时分秒的窗口
  865. ucPart=0;//进入到非设置时间的状态下
  866. ucWd2Update=1;//窗口2更新显示
  867. }
  868. else//按下去切换到显示日期的窗口
  869. {
  870. ucWd=1; //显示年月日的窗口
  871. ucPart=0;//进入到非设置时间的状态下
  872. ucWd1Update=1;//窗口1更新显示
  873. }
  875. }
  876. }
  878. void display_drive(void)
  879. {
  880. //以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
  881. switch(ucDisplayDriveStep)
  882. {
  883. case 1://显示第1位
  884. ucDigShowTemp=dig_table[ucDigShow1];
  885. if(ucDigDot1==1)
  886. {
  887. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  888. }
  889. dig_hc595_drive(ucDigShowTemp,0xfe);
  890. break;
  891. case 2://显示第2位
  892. ucDigShowTemp=dig_table[ucDigShow2];
  893. if(ucDigDot2==1)
  894. {
  895. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  896. }
  897. dig_hc595_drive(ucDigShowTemp,0xfd);
  898. break;
  899. case 3://显示第3位
  900. ucDigShowTemp=dig_table[ucDigShow3];
  901. if(ucDigDot3==1)
  902. {
  903. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  904. }
  905. dig_hc595_drive(ucDigShowTemp,0xfb);
  906. break;
  907. case 4://显示第4位
  908. ucDigShowTemp=dig_table[ucDigShow4];
  909. if(ucDigDot4==1)
  910. {
  911. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  912. }
  913. dig_hc595_drive(ucDigShowTemp,0xf7);
  914. break;
  915. case 5://显示第5位
  916. ucDigShowTemp=dig_table[ucDigShow5];
  917. if(ucDigDot5==1)
  918. {
  919. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  920. }
  921. dig_hc595_drive(ucDigShowTemp,0xef);
  922. break;
  923. case 6://显示第6位
  924. ucDigShowTemp=dig_table[ucDigShow6];
  925. if(ucDigDot6==1)
  926. {
  927. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  928. }
  929. dig_hc595_drive(ucDigShowTemp,0xdf);
  930. break;
  931. case 7://显示第7位
  932. ucDigShowTemp=dig_table[ucDigShow7];
  933. if(ucDigDot7==1)
  934. {
  935. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  936. }
  937. dig_hc595_drive(ucDigShowTemp,0xbf);
  938. break;
  939. case 8://显示第8位
  940. ucDigShowTemp=dig_table[ucDigShow8];
  941. if(ucDigDot8==1)
  942. {
  943. ucDigShowTemp=ucDigShowTemp|0x80;//显示小数点
  944. }
  945. dig_hc595_drive(ucDigShowTemp,0x7f);
  946. break;
  947. }
  948. ucDisplayDriveStep++;
  949. if(ucDisplayDriveStep>8)//扫描完8个数码管后，重新从第一个开始扫描
  950. {
  951. ucDisplayDriveStep=1;
  952. }
  954. }
  956. //数码管的74HC595驱动函数
  957. void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
  958. {
  959. unsigned char i;
  960. unsigned char ucTempData;
  961. dig_hc595_sh_dr=0;
  962. dig_hc595_st_dr=0;
  963. ucTempData=ucDigStatusTemp16_09;//先送高8位
  964. for(i=0;i<8;i++)
  965. {
  966. if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  967. else dig_hc595_ds_dr=0;
  968. dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  969. delay_short(1);
  970. dig_hc595_sh_dr=1;
  971. delay_short(1);
  972. ucTempData=ucTempData<<1;
  973. }
  974. ucTempData=ucDigStatusTemp08_01;//再先送低8位
  975. for(i=0;i<8;i++)
  976. {
  977. if(ucTempData>=0x80)dig_hc595_ds_dr=1;
  978. else dig_hc595_ds_dr=0;
  979. dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  980. delay_short(1);
  981. dig_hc595_sh_dr=1;
  982. delay_short(1);
  983. ucTempData=ucTempData<<1;
  984. }
  985. dig_hc595_st_dr=0;//ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  986. delay_short(1);
  987. dig_hc595_st_dr=1;
  988. delay_short(1);
  989. dig_hc595_sh_dr=0; //拉低，抗干扰就增强
  990. dig_hc595_st_dr=0;
  991. dig_hc595_ds_dr=0;
  992. }
  994. //LED灯的74HC595驱动函数
  995. void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
  996. {
  997. unsigned char i;
  998. unsigned char ucTempData;
  999. hc595_sh_dr=0;
  1000. hc595_st_dr=0;
  1001. ucTempData=ucLedStatusTemp16_09;//先送高8位
  1002. for(i=0;i<8;i++)
  1003. {
  1004. if(ucTempData>=0x80)hc595_ds_dr=1;
  1005. else hc595_ds_dr=0;
  1006. hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  1007. delay_short(1);
  1008. hc595_sh_dr=1;
  1009. delay_short(1);
  1010. ucTempData=ucTempData<<1;
  1011. }
  1012. ucTempData=ucLedStatusTemp08_01;//再先送低8位
  1013. for(i=0;i<8;i++)
  1014. {
  1015. if(ucTempData>=0x80)hc595_ds_dr=1;
  1016. else hc595_ds_dr=0;
  1017. hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
  1018. delay_short(1);
  1019. hc595_sh_dr=1;
  1020. delay_short(1);
  1021. ucTempData=ucTempData<<1;
  1022. }
  1023. hc595_st_dr=0;//ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
  1024. delay_short(1);
  1025. hc595_st_dr=1;
  1026. delay_short(1);
  1027. hc595_sh_dr=0; //拉低，抗干扰就增强
  1028. hc595_st_dr=0;
  1029. hc595_ds_dr=0;
  1030. }
  1034. void T0_time(void) interrupt 1 //定时中断
  1035. {
  1036. TF0=0;//清除中断标志
  1037. TR0=0; //关中断
  1040. /* 注释八：
  1041. * 以下是本节内容的核心程序，是定时器内部产生的时间。const_timer_1s这个是产生多少次定时中断才
  1042. * 算1秒钟的标准。这个标准决定了时钟的精度。这个标准最后是需要校验的。
  1043. */
  1044. if(ucTimerStart==1)//定时器的时间已经打开
  1045. {
  1046. uiTimerCnt++;//产生1秒钟的时基
  1047. if(uiTimerCnt>=const_timer_1s) //一秒钟的时间到。这个const_timer_1s具体数值最后需要校验得出。
  1048. {
  1049. uiTimerCnt=0; //清零为产生下一个1秒钟准备
  1050. ucTimerUpdate=1; //定时器每1秒钟所产生的标志，通知主函数及时更新采集时间数据
  1052. ucTimerSecond++; //秒时间累加1
  1053. if(ucTimerSecond>=60)
  1054. {
  1055. ucTimerSecond=0;
  1056. ucTimerMinute++; //分时间累加1
  1057. if(ucTimerMinute>=60)
  1058. {
  1059. ucTimerMinute=0;
  1060. ucTimerHour++;//小时的时间累加1，为了避免if的嵌套过多，把小时的判断放到外面两层的if来继续判断
  1061. }
  1062. }
  1064. if(ucTimerHour>=24)
  1065. {
  1066. ucTimerHour=0;
  1067. ucTimerDate++; //天时间累加1
  1068. ucTimerDateMax=get_date(ucTimerYear,ucTimerMonth);//根据年和月获取当前月份的最大天数
  1069. if(ucTimerDate>ucTimerDateMax)//
  1070. {
  1071. ucTimerDate=1; //每个月都是从1号开始
  1072. ucTimerMonth++;//月时间累加1
  1073. if(ucTimerMonth>12)
  1074. {
  1075. ucTimerMonth=1; //每年从1月份开始
  1076. ucTimerYear++; //年时间累加1
  1077. if(ucTimerYear>99) //本系统的最高有效年份是2099年
  1078. {
  1079. ucTimerYear=99;
  1080. }
  1081. }
  1082. }
  1083. }
  1085. }
  1088. }
  1090. if(ucVoiceLock==0) //原子锁判断
  1091. {
  1092. if(uiVoiceCnt!=0)
  1093. {
  1095. uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
  1096. beep_dr=0;//蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
  1098. }
  1099. else
  1100. {
  1102. ; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
  1103. beep_dr=1;//蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
  1105. }
  1106. }
  1111. if(ucDpyTimeLock==0) //原子锁判断
  1112. {
  1113. uiDpyTimeCnt++;//数码管的闪烁计时器
  1114. }
  1118. key_scan(); //按键扫描函数
  1119. display_drive();//数码管字模的驱动函数
  1121. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  1122. TL0=0x0b;
  1123. TR0=1;//开中断
  1124. }
  1126. void delay_short(unsigned int uiDelayShort)
  1127. {
  1128. unsigned int i;
  1129. for(i=0;i
  1130. {
  1131. ; //一个分号相当于执行一条空语句
  1132. }
  1133. }
  1135. void delay_long(unsigned int uiDelayLong)
  1136. {
  1137. unsigned int i;
  1138. unsigned int j;
  1139. for(i=0;i
  1140. {
  1141. for(j=0;j<500;j++)//内嵌循环的空指令数量
  1142. {
  1143. ; //一个分号相当于执行一条空语句
  1144. }
  1145. }
  1146. }
  1148. void initial_myself(void)//第一区 初始化单片机
  1149. {
  1151. key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
  1152. beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
  1153. hc595_drive(0x00,0x00);//关闭所有经过另外两个74HC595驱动的LED灯
  1154. TMOD=0x01;//设置定时器0为工作方式1
  1155. TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
  1156. TL0=0x0b;
  1158. }
  1159. void initial_peripheral(void) //第二区 初始化外围
  1160. {
  1162. ucDigDot8=0; //小数点全部不显示
  1163. ucDigDot7=0;
  1164. ucDigDot6=0;
  1165. ucDigDot5=0;
  1166. ucDigDot4=0;
  1167. ucDigDot3=0;
  1168. ucDigDot2=0;
  1169. ucDigDot1=0;
  1171. EA=1; //开总中断
  1172. ET0=1; //允许定时中断
  1173. TR0=1; //启动定时中断
  1176. }
总结陈词：
任何一个电子产品在投入生产的时候都要考虑到生产的测试，朱兆祺51单片机学习板在生产加工后也一样要进行测试。那么这个测试的程序如何能够做到快速，全面，易用这三个要求呢？欲知详情，请听下回分解-----生产朱兆祺51学习板的从机自检测试程序源代码.。

关键词： 单片机内部定时器时

评论


相关推荐

技术专区

关闭