时钟控制器（电子时钟）

`基于电子钟的控制器，其实相当于是闹钟的功能。学习来源是根据宋雪松老师的《手把手教你学单片机》。通过stc89c52+LCD1602+DS1302+矩阵按键+LED小灯实现的。具体现象，到固定时间小灯会自主亮灭。程序分为5个部分。程序所实现的现象为在10:00,10:02,10:05开始亮，在10:01,10:04,10:06开始灭。
protues的仿真图在下方

一：LCD1602液晶模块

1. #include
   
2. //控制LCD1602的位
   
3. #define LCD1602_DB P0        //数据位
   
4. ***it LCD1602_RS = P2^6;        //指令/数据选择信号
   
5. ***it LCD1602_RW = P2^5;        //读写选择信号
   
6. ***it LCD1602_E = P2^7;        //使能信号
   
7. 
   
8. /*LCD1602状态检测函数DB7为忙标志位，为1时禁止，为0是工作*/
   
9. void LcdWaitReady()
   
10. {
    
11.         unsigned char sta;                //用来缓存LCD1602_DB的值
    
12. 
    
13.         LCD1602_DB = 0xff;                //赋初值
    
14.         LCD1602_RS = 0;
    
15.         LCD1602_RW = 1;
    
16.         do {
    
17.                 LCD1602_E = 1;
    
18.                 sta = LCD1602_DB;
    
19.                 LCD1602_E = 0;
    
20.         }while (sta&0x80);         //当DB7为0时结束循环
    
21. }
    
22. 
    
23. /*LCD1602写指令函数，形参cmd-要输入的指令*/
    
24. void LcdWriteCmd(unsigned char cmd)
    
25. {
    
26.         LcdWaitReady();                //检测状态函数
    
27.         LCD1602_RS = 0;                //根据LCD1602时序图所写
    
28.         LCD1602_RW = 0;
    
29.         LCD1602_DB = cmd;
    
30.         LCD1602_E = 1;
    
31.         LCD1602_E = 0;        
    
32. }
    
33. 
    
34. /*LCD1602设置坐标函数，形参(x,y)-书写坐标*/
    
35. void LcdSetCursor(unsigned char x, unsigned char y)
    
36. {
    
37.         unsigned char addr;                        //书写地址
    
38. 
    
39.         if (y == 0)
    
40.                 addr = x + 0x00;
    
41.         else
    
42.                 addr = x + 0x40;
    
43.         LcdWriteCmd(addr | 0x80);  //写入书写的地址
    
44. }
    
45. 
    
46. /*LCD1602写入数据函数，形参dat-要写入的数据*/
    
47. void LcdWriteDat(unsigned char dat)
    
48. {
    
49.         LcdWaitReady();                                //状态检测函数
    
50.         LCD1602_RS = 1;
    
51.         LCD1602_RW = 0;
    
52.         LCD1602_DB = dat;
    
53.         LCD1602_E = 1;
    
54.         LCD1602_E = 0;
    
55. }
    
56. 
    
57. /*LCD1602开光标函数*/
    
58. void LcdOpenCursor()
    
59. {
    
60.         LcdWriteCmd(0x0f);
    
61. }
    
62. 
    
63. /*LCD1602关闭光标函数*/
    
64. void LcdCloseCursor()
    
65. {
    
66.         LcdWriteCmd(0x0c);
    
67. }
    
68. 
    
69. /*LCD1602显示字符函数，形参(x,y)-代表书写坐标，str-所写字符串的指针*/
    
70. void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str)
    
71. {
    
72.         LcdSetCursor(x, y);                        //设置坐标函数
    
73.         while (*str != '\0')
    
74.         {
    
75.                 LcdWriteDat(*str++);         //写数据函数
    
76.         }
    
77. }
    
78. 
    
79. /*LCD1602液晶初始化函数*/
    
80. void InitLcd1602()
    
81. {
    
82.         LcdWriteCmd(0x38);        //写指令函数。功能设置，8位数据总线，两行显示，5*7点阵
    
83.         LcdWriteCmd(0x0c);        //显示开关控制，开显示，游标不显示
    
84.         LcdWriteCmd(0x06);        //完成一个字符码传送后，光标右移，地址自动加1
    
85.         LcdWriteCmd(0x01);        //清显示
    
86. }

复制代码

二:矩阵按键模块

1. #include
   
2. //控制按键的位
   
3. ***it keyout1 = P1^7;
   
4. ***it keyout2 = P1^6;
   
5. ***it keyout3 = P1^5;
   
6. ***it keyout4 = P1^4;
   
7. ***it keyin1 = P1^3;
   
8. ***it keyin2 = P1^2;
   
9. ***it keyin3 = P1^1;
   
10. ***it keyin4 = P1^0;
    
11. 
    
12. unsigned char code KeyCodeMap[4][4] = {         //矩阵按键编号到标准键盘键码的印射表
    
13.         {'1', '2', '3', 0x26},                                 //数字键1，数字键2，数字键3，向上键
    
14.         {'4', '5', '6', 0x25},                                 //数字键4，数字键5，数字键6，向左键
    
15.         {'7', '8', '9', 0x28},                                 //数字键7，数字键8，数字键9，向下键
    
16.         {'0', 0x1b, 0x0d, 0x27}                                 //数字键0，ESC键，回车键，向右键
    
17. };
    
18. //用来保存按键的状态
    
19. unsigned char keysta[4][4] = {
    
20.         {1, 1, 1, 1},{1, 1, 1, 1},{1, 1, 1, 1},{1, 1, 1, 1}
    
21. };
    
22. 
    
23. extern void KeyAction(unsigned char keycode);
    
24. 
    
25. /*按键驱动函数，用来调用按键*/
    
26. void KeyDriver()
    
27. {        //用来保存上一次按键的状态
    
28.         static unsigned char backup[4][4] = {
    
29.                 {1,1,1,1},{1,1,1,1},{1,1,1,1},{1,1,1,1}
    
30.         };
    
31.         unsigned char i;
    
32.         unsigned char j;
    
33. 
    
34.         for (i = 0; i < 4; i++)        //构建两层循环来完成对矩阵按键的扫描
    
35.         {
    
36.                 for (j = 0; j < 4; j++)
    
37.                 {
    
38.                         if (keysta[i][j] != backup[i][j])
    
39.                         {
    
40.                                 if (backup[i][j] != 0)
    
41.                                 {
    
42.                                         KeyAction(KeyCodeMap[i][j]); //通过按键位置来执行相应的程序
    
43.                                 }
    
44.                                 backup[i][j] = keysta[i][j];
    
45.                         }
    
46.                 }
    
47.         }        
    
48. }
    
49. 
    
50. /*按键扫描函数，通过定时器0中断来完成1ms扫描一次*/
    
51. void KeyScan()
    
52. {
    
53.         static unsigned char keyout = 0;
    
54.         static unsigned char keybuff[4][4] = {        //用来消抖
    
55.                 {0xff, 0xff, 0xff, 0xff},{0xff, 0xff, 0xff, 0xff},
    
56.                 {0xff, 0xff, 0xff, 0xff},{0xff, 0xff, 0xff, 0xff}
    
57.         };
    
58.         unsigned char i;
    
59. 
    
60.         //将一行的4个按键值移入缓冲区
    
61.         keybuff[keyout][0] = (keybuff[keyout][0] << 1)|keyin1;
    
62.         keybuff[keyout][1] = (keybuff[keyout][1] << 1)|keyin2;
    
63.         keybuff[keyout][2] = (keybuff[keyout][2] << 1)|keyin3;
    
64.         keybuff[keyout][3] = (keybuff[keyout][3] << 1)|keyin4;
    
65.         //消抖后更新按键状态
    
66.         for (i = 0; i < 4; i++)
    
67.         {
    
68.                 if ((keybuff[keyout][i]&0x0f) == 0x0f)
    
69.                 {//连续4次扫描值为1，即4*4ms内都是弹起状态时，可以认为按键已稳定弹起
    
70.                         keysta[keyout][i] = 1;
    
71.                 }
    
72.                 else if ((keybuff[keyout][i]&0x0f) == 0x00)
    
73.                 {//连续4次扫描值为0，即4*4ms内都是按下状态时，可以认为按键已稳定按下
    
74.                         keysta[keyout][i] = 0;
    
75.                 }
    
76.         }
    
77.         keyout++;
    
78.         if (keyout >= 4)
    
79.                 keyout = 0;
    
80.         switch (keyout)
    
81.         {  //每次拉低一个按键的值
    
82.                 case 0:keyout1=0;keyout2=1;keyout3=1;keyout4=1;break;
    
83.                 case 1:keyout1=1;keyout2=0;keyout3=1;keyout4=1;break;
    
84.                 case 2:keyout1=1;keyout2=1;keyout3=0;keyout4=1;break;
    
85.                 case 3:keyout1=1;keyout2=1;keyout3=1;keyout4=0;break;
    
86.                 default:break;
    
87.         }
    
88. }

复制代码

三：DS1302时钟芯片模块（单字节读出函数未使用）

1. #include
   
2. #include
   
3. //控制DS1302时钟的位
   
4. ***it DS1302_SK = P3^6;                        //时钟信号端，通过控制其高低电平来输入/输出数据
   
5. ***it DS1302_IO = P3^4;                        //输入输出数据端
   
6. ***it DS1302_CE = P3^5;                        //使能端，高电平时有效
   
7. 
   
8. struct sTime {                                           //定义时间结构体
   
9.         unsigned char year;                        //年
   
10.         unsigned char mon;                        //月
    
11.         unsigned char day;                        //日
    
12.         unsigned char hour;                        //时
    
13.         unsigned char min;                        //分
    
14.         unsigned char sec;                        //秒
    
15.         unsigned char week;                        //星期
    
16. };
    
17. 
    
18. /*DS1302读出函数，根据时序图编写，返回值为读出的数据*/
    
19. unsigned char DS1302ByteRead()
    
20. {
    
21.         unsigned char dat = 0;
    
22.         unsigned char mask;
    
23. 
    
24.         for (mask=0x01; mask!=0; mask<<=1)
    
25.         {
    
26.                 if (DS1302_IO != 0)
    
27.                         dat |= mask;
    
28.                 DS1302_SK = 1;        //先准备好数据，然后拉高SK
    
29.                 _nop_();
    
30.                 DS1302_SK = 0;        //拉低SK
    
31.                 _nop_();
    
32.         }
    
33. 
    
34.         return dat;
    
35. }
    
36. 
    
37. /*DS1302写入函数，根据时序图编写，dat-写入的数据*/
    
38. void DS1302ByteWrite(unsigned char dat)
    
39. {
    
40.         unsigned char mask;
    
41. 
    
42.         for (mask=0x01; mask!=0; mask<<=1)
    
43.         {
    
44.                 if ((mask&dat) != 0) //将输入数据的位从最低位依次输入
    
45.                         DS1302_IO = 1;
    
46.                 else
    
47.                         DS1302_IO = 0;
    
48.                 DS1302_SK = 1;                 //先准备好数据，拉高SK，数据采样
    
49.                 _nop_();
    
50.                 DS1302_SK = 0;                 //拉低SK，数据输出
    
51.                 _nop_();
    
52.         }
    
53.         DS1302_IO = 1;                            //释放IO引脚
    
54. }
    
55. 
    
56. /*DS1302单字节读出函数，addr-写入要读字节的寄存器地址，返回值为读出的数据*/
    
57. unsigned char DS1302SingleRead(unsigned char addr)
    
58. {
    
59.         unsigned char dat;
    
60. 
    
61.         DS1302_CE = 1;
    
62.         _nop_();
    
63.         DS1302ByteWrite(addr);
    
64.         dat = DS1302ByteRead();
    
65.         DS1302_CE = 0;
    
66.         _nop_();
    
67. 
    
68.         return dat;
    
69. }
    
70. 
    
71. /*DS1302单字节写入函数,addr-写入字节的寄存器地址，dat-写入数据*/
    
72. void DS1302SingleWrite(unsigned addr, unsigned dat)
    
73. {
    
74.         DS1302_CE = 1;
    
75.         _nop_();
    
76.         DS1302ByteWrite(addr);
    
77.         DS1302ByteWrite(dat);
    
78.         DS1302_CE = 0;
    
79.         _nop_();
    
80. }
    
81. 
    
82. /*DS1302Burst写入模式，一次写入8个字节,dat-写入数据的指针*/
    
83. void DS1302BurstWrite(unsigned char *dat)
    
84. {
    
85.         unsigned char i;
    
86. 
    
87.         DS1302_CE = 1;
    
88.         _nop_();
    
89.         DS1302ByteWrite(0xbe);
    
90.         for (i = 0; i < 8; i++)
    
91.         {
    
92.                 DS1302ByteWrite(*dat++);
    
93.         }
    
94.         DS1302_CE = 0;
    
95.         _nop_();
    
96. }
    
97. 
    
98. /*DS1302Burst读出模式，一次读出8个字节，dat-存储读出数据的指针*/
    
99. void DS1302BurstRead(unsigned char * dat)
    
100. {
     
101.         unsigned char i;
     
102. 
     
103.         DS1302_CE = 1;
     
104.         _nop_();
     
105.         DS1302ByteWrite(0xbf);
     
106.         for (i = 0; i < 8; i++)
     
107.         {
     
108.                 *dat++ = DS1302ByteRead();
     
109.         }
     
110.         DS1302_CE = 0;
     
111.         _nop_();
     
112. }
     
113. 
     
114. /*获取实时时间，time-存储时间的结构体*/
     
115. void GetRealTime(struct sTime * time)
     
116. {
     
117.         unsigned char buf[8];
     
118. 
     
119.         DS1302BurstRead(buf);
     
120.         time->year = buf[6] + 0x2000;
     
121.         time->week = buf[5];
     
122.         time->mon = buf[4];
     
123.         time->day = buf[3];
     
124.         time->hour = buf[2];
     
125.         time->min = buf[1];
     
126.         time->sec = buf[0];
     
127. }
     
128. 
     
129. /*设置实时时间，dat-要写入的数据的结构体*/
     
130. void SetRealTime(struct sTime * dat)
     
131. {
     
132.         unsigned char buf[8];
     
133. 
     
134.         buf[7] = 0x00;
     
135.         buf[6] = dat->year;
     
136.         buf[5] = dat->week;
     
137.         buf[4] = dat->mon;
     
138.         buf[3] = dat->day;
     
139.         buf[2] = dat->hour;
     
140.         buf[1] = dat->min;
     
141.         buf[0] = dat->sec;
     
142.         DS1302BurstWrite(buf);
     
143. }
     
144. 
     
145. /*初始化DS1302函数*/
     
146. void InitDS1302()
     
147. {
     
148.         struct sTime code InitTime[] = {0x2019, 0x10, 0x11, 0x09, 0x59, 0x50, 0x05};
     
149. 
     
150.         DS1302_CE = 0;
     
151.         _nop_();                                       //延时一个机器周期
     
152.         DS1302_SK = 0;
     
153.         _nop_();
     
154.         DS1302SingleWrite(0x8e, 0x00); //撤销写保护，0x8e-写保护位的地址，0x00-撤销写保护
     
155.         SetRealTime(InitTime);                   //设置初始时间
     
156.         DS1302SingleWrite(0x8e, 0x80); //添加写保护
     
157. }

复制代码

四：设置时间函数

1. #include
   
2. 
   
3. struct sTime {                                        //定义时间结构体
   
4.         unsigned char year;                        //年
   
5.         unsigned char mon;                    //月
   
6.         unsigned char day;                        //日
   
7.         unsigned char hour;                        //时
   
8.         unsigned char min;                        //分
   
9.         unsigned char sec;                        //秒
   
10.         unsigned char week;                        //星期
    
11. };
    
12. 
    
13. struct sTime bufTime;                        //时间缓冲区
    
14. unsigned char setIndex = 0;                //设置标志位
    
15. /*函数声明*/
    
16. extern void RefreshTime();
    
17. extern void LcdSetCursor(unsigned char x, unsigned char y);
    
18. extern void SetRealTime(struct sTime * dat);
    
19. extern void LcdCloseCursor();
    
20. extern void LcdOpenCursor();
    
21. 
    
22. /*刷新当前设置位的光标指示*/
    
23. void RefreshSetShow()
    
24. {
    
25.         switch(setIndex)
    
26.         {
    
27.                 case 1:LcdSetCursor(2, 0);break;
    
28.                 case 2:LcdSetCursor(3, 0);break;
    
29.                 case 3:LcdSetCursor(5, 0);break;
    
30.                 case 4:LcdSetCursor(6, 0);break;
    
31.                 case 5:LcdSetCursor(8, 0);break;
    
32.                 case 6:LcdSetCursor(9, 0);break;
    
33.                 case 7:LcdSetCursor(15, 0);break;
    
34.                 case 8:LcdSetCursor(4, 1);break;
    
35.                 case 9:LcdSetCursor(5, 1);break;
    
36.                 case 10:LcdSetCursor(7, 1);break;
    
37.                 case 11:LcdSetCursor(8, 1);break;
    
38.                 case 12:LcdSetCursor(10, 1);break;
    
39.                 case 13:LcdSetCursor(11, 1);break;
    
40.                 default:break;
    
41.         }
    
42. }
    
43. 
    
44. /***********************************************************************/
    
45. //递增或递减分，秒的BCD码
    
46. /*递增一个BCD码的高位*/
    
47. unsigned char IncTimeBcdHigh(unsigned char bcd)
    
48. {
    
49.         if ((bcd&0xf0) < 0x50)
    
50.                 bcd += 0x10;
    
51.         else
    
52.                 bcd &= 0x0f;
    
53. 
    
54.         return bcd;
    
55. }
    
56. 
    
57. /*递减一个BCD码的高位*/
    
58. unsigned char DecTimeBcdHigh(unsigned char bcd)
    
59. {
    
60.         if ((bcd&0xf0) > 0x00)
    
61.                 bcd -= 0x10;
    
62.         else
    
63.                 bcd |= 0x50;
    
64. 
    
65.         return bcd;
    
66. }
    
67. 
    
68. //递增或递减时，分，秒的BCD码
    
69. /********************************************************************/
    
70. 
    
71. /*递增一个BCD码的高位*/
    
72. unsigned char IncBcdHigh(unsigned char bcd)
    
73. {
    
74.         if ((bcd&0xf0) < 0x90)
    
75.                 bcd += 0x10;
    
76.         else
    
77.                 bcd &= 0x0f;
    
78. 
    
79.         return bcd;
    
80. }
    
81. 
    
82. /*递增一个BCD码的低位*/
    
83. unsigned char IncBcdLow(unsigned char bcd)
    
84. {
    
85.         if ((bcd&0x0f) < 0x09)
    
86.                 bcd += 0x01;
    
87.         else
    
88.                 bcd &= 0xf0;
    
89. 
    
90.         return bcd;
    
91. }
    
92. 
    
93. /*递减一个BCD码的高位*/
    
94. unsigned char DecBcdHigh(unsigned char bcd)
    
95. {
    
96.         if ((bcd&0xf0) > 0x00)
    
97.                 bcd -= 0x10;
    
98.         else
    
99.                 bcd |= 0x90;
    
100. 
     
101.         return bcd;
     
102. }
     
103. 
     
104. /*递减一个BCD码的低位*/
     
105. unsigned char DecBcdLow(unsigned char bcd)
     
106. {
     
107.         if ((bcd&0x0f) > 0x00)
     
108.                 bcd -= 0x01;
     
109.         else
     
110.                 bcd |= 0x09;
     
111. 
     
112.         return bcd;
     
113. }
     
114. 
     
115. /*递增周的BCD码*/
     
116. unsigned char IncWeekBcd(unsigned char bcd)
     
117. {
     
118.         if ((bcd&0x0f) < 0x07)
     
119.                 bcd += 0x01;
     
120.         else
     
121.                 bcd = 0x00;        
     
122. 
     
123.         return bcd;
     
124. }
     
125. 
     
126. /*递减周的BCD码*/
     
127. unsigned char DecWeekBcd(unsigned char bcd)
     
128. {
     
129.         if ((bcd&0x0f) > 0x00)
     
130.                 bcd -= 0x01;
     
131.         else
     
132.                 bcd = 0x07;
     
133. 
     
134.         return bcd;
     
135. }
     
136. 
     
137. /*递增时间当前设置位的值*/
     
138. void IncSetTime()
     
139. {
     
140.         switch(setIndex)
     
141.         {
     
142.                 case 1:bufTime.year = IncBcdHigh(bufTime.year);break;
     
143.                 case 2:bufTime.year = IncBcdLow(bufTime.year);break;
     
144.                 case 3:bufTime.mon = IncBcdHigh(bufTime.mon);break;
     
145.                 case 4:bufTime.mon = IncBcdLow(bufTime.mon);break;
     
146.                 case 5:bufTime.day = IncBcdHigh(bufTime.day);break;
     
147.                 case 6:bufTime.day = IncBcdLow(bufTime.day);break;
     
148.                 case 7:bufTime.week = IncWeekBcd(bufTime.week);break;
     
149.                 case 8:bufTime.hour = IncBcdHigh(bufTime.hour);break;
     
150.                 case 9:bufTime.hour = IncBcdLow(bufTime.hour);break;
     
151.                 case 10:bufTime.min = IncTimeBcdHigh(bufTime.min);break;
     
152.                 case 11:bufTime.min = IncBcdLow(bufTime.min);break;
     
153.                 case 12:bufTime.sec = IncTimeBcdHigh(bufTime.sec);break;
     
154.                 case 13:bufTime.sec = IncBcdLow(bufTime.sec);break;
     
155.                 default:break;
     
156.         }
     
157.         RefreshTime();
     
158.         RefreshSetShow();
     
159. }
     
160. 
     
161. /*递减时间当前设置位的值*/
     
162. void DecSetTime()
     
163. {
     
164.         switch(setIndex)
     
165.         {
     
166.                 case 1:bufTime.year = DecBcdHigh(bufTime.year);break;
     
167.                 case 2:bufTime.year = DecBcdLow(bufTime.year);break;
     
168.                 case 3:bufTime.mon = DecBcdHigh(bufTime.mon);break;
     
169.                 case 4:bufTime.mon = DecBcdLow(bufTime.mon);break;
     
170.                 case 5:bufTime.day = DecBcdHigh(bufTime.day);break;
     
171.                 case 6:bufTime.day = DecBcdLow(bufTime.day);break;
     
172.                 case 7:bufTime.week = DecWeekBcd(bufTime.week);break;
     
173.                 case 8:bufTime.hour = DecBcdHigh(bufTime.hour);break;
     
174.                 case 9:bufTime.hour = DecBcdLow(bufTime.hour);break;
     
175.                 case 10:bufTime.min = DecTimeBcdHigh(bufTime.min);break;
     
176.                 case 11:bufTime.min = DecBcdLow(bufTime.min);break;
     
177.                 case 12:bufTime.sec = DecTimeBcdHigh(bufTime.sec);break;
     
178.                 case 13:bufTime.sec = DecBcdLow(bufTime.sec);break;
     
179.                 default:break;
     
180.         }
     
181.         RefreshTime();
     
182.         RefreshSetShow();        
     
183. }
     
184. 
     
185. /*光标左移函数*/
     
186. void LeftShift()
     
187. {
     
188.         if (setIndex != 0)
     
189.         {
     
190.                 if (setIndex > 1)
     
191.                 {
     
192.                         setIndex--;
     
193.                 }
     
194.                 else
     
195.                 {
     
196.                         setIndex = 13;
     
197.                 }
     
198.                 RefreshSetShow();
     
199.         }
     
200. }
     
201. 
     
202. /*光标右移函数*/
     
203. void RightShift()
     
204. {
     
205.         if (setIndex != 0)
     
206.         {
     
207.                 if (setIndex < 13)
     
208.                 {
     
209.                         setIndex++;
     
210.                 }
     
211.                 else
     
212.                 {
     
213.                         setIndex = 1;
     
214.                 }
     
215.                 RefreshSetShow();
     
216.         }
     
217. }
     
218. 
     
219. /*退出时间设置函数，save-是否保存标志*/
     
220. void ExitSetTime(bit save)
     
221. {
     
222.         setIndex = 0;
     
223.         if (save)
     
224.         {
     
225.                 SetRealTime(&bufTime);
     
226.         }
     
227.         LcdCloseCursor();
     
228. }
     
229. 
     
230. /*进入时间设置函数*/
     
231. void EnterSetTime()
     
232. {
     
233.         setIndex = 2;                        //先把设置标志位设为2，再向左移
     
234.         LeftShift();
     
235.         LcdOpenCursor();
     
236. }
     
237. 
     
238. /*按键执行函数，keycode-所传递的哪一个按键被按下*/
     
239. void KeyAction(unsigned char keycode)
     
240. {
     
241.         if (keycode >= '0' && keycode <= '9')
     
242.         {
     
243.         //数字按键不执行任何动作
     
244.         }
     
245.         else if (keycode == 0x26)          //数字键加
     
246.         {
     
247.                 IncSetTime();
     
248.         }
     
249.         else if (keycode == 0x28)          //数字键减
     
250.         {
     
251.                 DecSetTime();
     
252.         }
     
253.         else if (keycode == 0x25)          //光标向左移动
     
254.         {
     
255.                 LeftShift();
     
256.         }
     
257.         else if (keycode == 0x27)          //光标向右移动
     
258.         {
     
259.                 RightShift();
     
260.         }
     
261.         else if (keycode == 0x0d)          //进入/退出时间设置
     
262.         {
     
263.                 if (setIndex == 0)
     
264.                 {
     
265.                         EnterSetTime();
     
266.                 }
     
267.                 else
     
268.                 {
     
269.                         ExitSetTime(1);          //保存数据并退出
     
270.                 }
     
271.         }
     
272.         else if (keycode == 0x1b)          //取消键
     
273.         {
     
274.                 ExitSetTime(0);                  //不保存数据
     
275.         }
     
276. }

复制代码

五：主程序

1. #include
   
2. //控制小灯的位
   
3. ***it led1 = P2^0;
   
4. ***it led2 = P2^1;
   
5. ***it led3 = P2^2;
   
6. 
   
7. //小灯开启时间表
   
8. ledstarthour[3] = {0x10, 0x10, 0x10};
   
9. ledstartmin[3] = {0x00, 0x02, 0x05};
   
10. //小灯关闭时间表
    
11. ledclosehour[3] = {0x10, 0x10, 0x10};
    
12. ledclosemin[3] = {0x01, 0x04, 0x06};
    
13. 
    
14. struct sTime {                                        //定义时间结构体
    
15.         unsigned char year;                        //年
    
16.         unsigned char mon;                        //月
    
17.         unsigned char day;                        //日
    
18.         unsigned char hour;                        //时
    
19.         unsigned char min;                        //分
    
20.         unsigned char sec;                        //秒
    
21.         unsigned char week;                        //星期
    
22. };
    
23. 
    
24. bit flag200ms = 0;                                                //定时标志
    
25. extern struct sTime bufTime;                        //时间缓冲区
    
26. extern unsigned char setIndex ;                    //设置标志位
    
27. unsigned char T0RH = 0;                                        //定时器的高8位
    
28. unsigned char T0RL = 0;                                        //定时器的低8位
    
29. /*函数声明*/
    
30. extern void KeyScan();
    
31. void configTimer0(unsigned char ms);
    
32. extern void InitLcd1602();
    
33. extern void InitDS1302();
    
34. extern void LcdShowStr(unsigned char x, unsigned char y, unsigned char *str);
    
35. extern void KeyDriver();
    
36. extern void GetRealTime(struct sTime * time);
    
37. void RefreshTime();
    
38. void LedStartMonitor();
    
39. void LedCloseMonitor();
    
40. 
    
41. void main()
    
42. {
    
43.         unsigned char psec = 0xaa;        //秒备份
    
44. 
    
45.         EA = 1;                                                //开总中断
    
46.         configTimer0(1);                        //为定时器0配置时间
    
47.         InitLcd1602();                                //初始化液晶显示屏
    
48.         InitDS1302();                                //初始化时钟
    
49.         //显示液晶上固定的位
    
50.         LcdShowStr(0, 0, "20  -  -   week ");
    
51.         LcdShowStr(4, 1, "  :  :  ");
    
52. 
    
53.         while (1)
    
54.         {
    
55.                 KeyDriver();                                //按键驱动
    
56.                 if (flag200ms && (setIndex == 0))
    
57.                 {
    
58.                         flag200ms = 0;
    
59.                         GetRealTime(&bufTime);                 //获取实时时间
    
60.                         LedStartMonitor();
    
61.                         LedCloseMonitor();
    
62.                         if (psec != bufTime.sec)        //如果秒发生变化，就刷新时间
    
63.                         {
    
64.                                 RefreshTime();
    
65.                                 psec = bufTime.sec;
    
66.                         }
    
67.                 }
    
68.         }
    
69. }
    
70. 
    
71. /*监控时间开启小灯函数，当到达指定时间，小灯亮*/
    
72. void LedStartMonitor()
    
73. {
    
74.         static unsigned char i = 0;
    
75.         if ((bufTime.hour == ledstarthour[i])&&(bufTime.min == ledstartmin[i]))
    
76.         {
    
77.                 led1 = 0;
    
78.                 led2 = 0;
    
79.                 led3 = 0;
    
80.                 i++;
    
81.                 if (i >= 3)
    
82.                         i = 0;
    
83.         }
    
84. }
    
85. 
    
86. /*监控时间关闭小灯函数，当到达指定时间，小灯灭*/
    
87. void LedCloseMonitor()
    
88. {
    
89.         static unsigned char i = 0;
    
90.         if ((bufTime.hour == ledclosehour[i])&&(bufTime.min == ledclosemin[i]))
    
91.         {
    
92.                 led1 = 1;
    
93.                 led2 = 1;
    
94.                 led3 = 1;
    
95.                 i++;
    
96.                 if (i >= 3)
    
97.                         i = 0;
    
98.         }
    
99. }
    
100. 
     
101. /*将BCD码转换为字符串*/
     
102. void ShowBcdByte(unsigned char x, unsigned char y, unsigned char dat)
     
103. {
     
104.         unsigned char buf[3];
     
105.         if (x == 15)                                 //对“周”的特殊照顾
     
106.         {
     
107.                 buf[0] = (dat&0x0f)+'0';
     
108.                 buf[1] = '\0';
     
109.         }
     
110.         else
     
111.         {
     
112.                 buf[0] = (dat>>4)+'0';         
     
113.                 buf[1] = (dat&0x0f)+'0';
     
114.                 buf[2] = '\0';
     
115.         }
     
116.         LcdShowStr(x, y, buf);
     
117. }
     
118. 
     
119. /*刷新时间函数*/
     
120. void RefreshTime()
     
121. {
     
122.         ShowBcdByte(2, 0, bufTime.year);
     
123.         ShowBcdByte(5, 0, bufTime.mon);
     
124.         ShowBcdByte(8, 0, bufTime.day);
     
125.         ShowBcdByte(15, 0, bufTime.week);
     
126.         ShowBcdByte(4, 1, bufTime.hour);
     
127.         ShowBcdByte(7, 1, bufTime.min);
     
128.         ShowBcdByte(10, 1, bufTime.sec);
     
129. }
     
130. 
     
131. /*配置定时器0*/
     
132. void configTimer0(unsigned char ms)
     
133. {
     
134.         unsigned long temp;
     
135. 
     
136.         temp = 11059200 / 12;
     
137.         temp = (temp*ms)/1000;
     
138.         temp = 65536 - temp;
     
139.         T0RH = (unsigned char)(temp >> 8);
     
140.         T0RL = (unsigned char)temp;
     
141.         TMOD &= 0xf0;
     
142.         TMOD |= 0x01;
     
143.         TH0 = T0RH;
     
144.         TL0 = T0RL;
     
145.         TR0 = 1;
     
146.         ET0 = 1;                //打开定时器0中断
     
147. }
     
148. 
     
149. /*中断函数*/
     
150. void InterruptTimer0()                        interrupt 1
     
151. {
     
152.         static unsigned char tmr200ms = 0;
     
153. 
     
154.         TH0 = T0RH;
     
155.         TL0 = T0RL;
     
156.         KeyScan();
     
157.         tmr200ms++;
     
158.         if (tmr200ms >= 200)
     
159.         {
     
160.                 tmr200ms = 0;
     
161.                 flag200ms = 1;
     
162.         }
     
163. }

复制代码

`