时钟闹表程序.docx

时钟闹表程序.docx

《时钟闹表程序.docx》由会员分享，可在线阅读，更多相关《时钟闹表程序.docx（60页珍藏版）》请在冰豆网上搜索。

时钟闹表程序

1.#include    

2.#include       

3.unsigned char data dis_digit;   

4.unsigned char key_s, key_v;      

5.unsigned char code dis_code[11]={0xc0,0xf9,0xa4,0xb0, // 0, 1, 2, 3   0x99,0x92,0x82,0xf8,0x80,0x90, 0xff};// 4, 5, 6, 7, 8, 9, off    

6.unsigned char data dis_buf[8];   

7.unsigned char data dis_index;   

8.unsigned char hour,min,sec;   

9.unsigned char sec100;       

10.sbit K1 = P1^4;   

11.sbit K2 = P1^5;      

12.bit scan_key（）;   

13.void proc_key（）;   

14.void inc_sec（）;   

15.void inc_min（）;   

16.void inc_hour（）;   

17.void display（）;   

18.void delayms（unsigned char ms）;      

19.void main（void）   

20.{   

21.P0 = 0xff;   

22.P2 = 0xff;   

23.TMOD = 0x11;   // 定时器0, 1工作模式1, 16位定时方式   

24.TH1 = 0xdc;   

25.TL1 = 0;      

26.TH0 = 0xFC;   

27.TL0 = 0x17;      

28.hour = 12;   

29.min = 00;   

30.sec = 00;      

31.sec100 = 0;      

32.dis_buf[0] = dis_code[hour / 10];   // 时十位   

33.dis_buf[1] = dis_code[hour % 10];   // 时个位   

34.dis_buf[3] = dis_code[min / 10];   // 分十位   

35.dis_buf[4] = dis_code[min % 10];   // 分个位   

36.dis_buf[6] = dis_code[sec / 10];   // 秒十位   

37.dis_buf[7] = dis_code[sec % 10];   // 秒个位   

38.dis_buf[2] = 0xbf;       // 显示"-"   

39.dis_buf[5] = 0xbf;       // 显示"-"         

40.dis_digit = 0xfe;   

41.dis_index = 0;      

42.TCON = 0x01;   

43.IE = 0x8a;     // 使能timer0,1 中断      

44.TR0 = 1;   

45.TR1 = 1;      

46.key_v = 0x03;      

47.while

（1）   

48.{   

49.   if（scan_key（））   

50.   {   

51.    delayms（10）;   

52.    if（scan_key（））   

53.    {   

54.     key_v = key_s;   

55.     proc_key（）;   

56.    }   

57.   }   

58.}   

59.}      

60.bit scan_key（）   

61.{   

62.key_s = 0x00;   

63.key_s |= K2;   

64.key_s <<= 1;   

65.key_s |= K1;   

66.return（key_s ^ key_v）;    

67.}      

68.void proc_key（）   

69.{   

70.EA = 0;   

71.if（（key_v & 0x01） == 0）   // K1   

72.{   

73.   inc_hour（）;   

74.}   

75.else if（（key_v & 0x02） == 0） // K2   

76.{   

77.   min++;   

78.   if（min > 59）   

79.   {   

80.    min = 0;   

81.   }   

82.   dis_buf[3] = dis_code[min / 10];   // 分十位   

83.   dis_buf[4] = dis_code[min % 10];   // 分个位   

84.}   

85.EA = 1;   

86.}   

87.void timer0（） interrupt 1   

88.// 定时器0中断服务程序, 用于数码管的动态扫描   

89.// dis_index --- 显示索引, 用于标识当前显示的数码管和缓冲区的偏移量   

90.// dis_digit --- 位选通值, 传送到P2口用于选通当前数码管的数值, 如等于0xfe时,

91.//     选通P2.0口数码管   

92.// dis_buf    --- 显于缓冲区基地址    

93.{   

94.TH0 = 0xFC;   

95.TL0 = 0x17;      

96.P2 = 0xff;        // 先关闭所有数码管   

97.P0 = dis_buf[dis_index];    // 显示代码传送到P0口   

98.P2 = dis_digit;       //       

99.dis_digit = _crol_（dis_digit,1）; // 位选通值左移,下次中断时选通下一位数码管

100.dis_index++;       //            

101.dis_index &= 0x07;//8个数码管全部扫描完一遍之后，再回到第一个开始下一次扫描

102.}       

103.void timer1（） interrupt 3   

104.{   

105.TH1 = 0xdc;     

106.sec100++;      

107.if（sec100 >= 100）   

108.{   

109.   sec100 = 0;   

110.   inc_sec（）;   

111.}   

112.}   

113.   

114.void inc_sec（）   

115.{   

116.sec++;   

117.if（sec > 59）   

118.{   

119.   sec = 0;   

120.   inc_min（）;   

121.}   

122.dis_buf[6] = dis_code[sec / 10];   // 秒十位   

123.dis_buf[7] = dis_code[sec % 10];   // 秒个位    

124.}      

125.void inc_min（）   

126.{   

127.min++;   

128.if（min > 59）   

129.{   

130.   min = 0;   

131.   inc_hour（）;   

132.}   

133.dis_buf[3] = dis_code[min / 10];   // 分十位   

134.dis_buf[4] = dis_code[min % 10];   // 分个位   

135.}      

136.void inc_hour（）   

137.{   

138.hour++;   

139.if（hour > 23）   

140.{   

141.   hour = 0;   

142.}   

143.if（hour > 9）   

144.   dis_buf[0] = dis_code[hour / 10];   // 时十位   

145.else   

146.   dis_buf[0] = 0xff;      // 当小时的十位为0时不显示   

147.dis_buf[1] = dis_code[hour % 10];   // 时个位   

148.   

149.}      

150.void delayms（unsigned char ms）    

151.// 延时子程序   

152.{         

153.unsigned char i;   

154.while（ms--）   

155.{   

156.   for（i = 0; i < 120; i++）;   

157.}   

158.}  

/***************************************************************  

1.文件名：

alarm.c                         

2.描  述:

 时钟闹表程序。

在LED上显示当前时间。

按BUTTON_1键，进入修改状态，    

3.        按BUTTON_2一次，要修改项加一。

4.函  数：

 read_alarm（）  

5.         write_alarm（）  

6.         read_control（）  

7.         modify_alarm_hour（）  

8.         modify_alarm_minute（）  

9.         modify_time_hour（）  

10.         modify_time_minute（）  

11.         InitTimer0（）  

12.         timer0（）  

13.不   足：

1、修改时钟和闹钟时，不需修改的相应的段也会跟着闪烁显示。

需改进，  

14.         尚没找到原因，如果哪位大虾知道原因，请告知haohaozi000@.  

15.         2、程序中注释太少，以后慢慢完善吧。

16.spot    2005-12-10     Creat Inital version. （Version 1.0）          

17.*************************************************************/   

18.#include    

19.#include    

20.#include    

21.#include    

22.#include    

23.#include    

24.#include       

25./* 键码定义 */   

26.#define BUTTON_1  0xEE   

27.#define BUTTON_2  0xDE   

28.#define BUTTON_3  0xBE   

29.#define BUTTON_4  0x7E   

30.#define BUTTON_5  0xED   

31.#define BUTTON_6  0xDD   

32.#define BUTTON_7  0xBD   

33.#define BUTTON_8  0x7D   

34.#define BUTTON_9  0xEB   

35.#define BUTTON_10 0xDB   

36.#define BUTTON_11 0xBB   

37.#define BUTTON_12 0x7B   

38.#define BUTTON_13 0xE7   

39.#define BUTTON_14 0xD7   

40.#define BUTTON_15 0xB7   

41.#define BUTTON_16 0x77   

42./* 定义结束 */      

43.#define    RELOAD_HIGH     0x4c // 11.0592MHz crystal   

44.#define    RELOAD_LOW      0x0      

45.extern void sd2300_write_date（void）;   

46.extern void time_hour_blink（void）;   

47.extern void time_minute_blink（void）;   

48.extern void alarm_hour_blink（void）;   

49.extern void alarm_minute_blink（void）;   

50.extern u_char scan_key（void）;      

51.sbit alarm_on = P3^4;   

52.u_char control[2];   

53.u_char tick;   

54.u_char alarm[2];   

55.extern u_char date[7];     

56.//read_alarm（）用来读取定时寄存器A的中的数据     

57.void read_alarm（void）   

58.{   

59.    u_char i;   

60.    sd2300_start（）;   

61.    sd2300_send_byte（0x64）;   

62.    sd2300_wait_ack（）;   

63.    sd2300_send_byte（0x80）;       // 从A定时器的分开始读取数据   

64.    sd2300_wait_ack（）;      

65.    sd2300_start（）;   

66.    sd2300_send_byte（0x65）;   

67.    sd2300_wait_ack（）;      

68.    for （i=0; i<2; i++）   

69.    {   

70.        alarm[1-i] = sd2300_receive_byte（）;//alarm[1]为分，alarm[0]为小时

71.        if （i !

= 1）                    // 最后一个数据不应答   

72.        {   

73.            sd2300_ack（）;   

74.        }   

75.    }   

76.   

77.    sd2300_no_ack（）;   

78.    sd2300_stop（）;   

79.}   

80.//write_alarm（）用来往定时寄存器A中写入数据   

81.void write_alarm（ void ）   

82.{   

83.    sd2300_start（）;   

84.    sd2300_send_byte（0x64）;   

85.    sd2300_wait_ack（）;   

86.    sd2300_send_byte（0x80）;       // 先写定时器A的分，再写小时   

87.    sd2300_wait_ack（）;   

88.   

89.    sd2300_send_byte（alarm[1]）;             //写定时器的分alarm[1]   

90.    sd2300_wait_ack（）;   

91.      

92.    sd2300_send_byte（alarm[0]）;             //写定时期的小时alarm[0]   

93.    sd2300_wait_ack（）;   

94.    sd2300_stop（）;   

95.}   

96.      

97.//读取控制寄存器中的数据   

98.void read_control（void）   

99.{   

100.    u_char i;   

101.   

102.    sd2300_start（）;   

103.    sd2300_send_byte（0x64）;   

104.    sd2300_wait_ack（）;   

105.    sd2300_send_byte（0xe0）;        // 从控制器1开始读取数据   

106.    sd2300_wait_ack（）;   

107.   

108.    sd2300_start（）;   

109.    sd2300_send_byte（0x65）;   

110.    sd2300_wait_ack（）;   

111.   

112.    for （i=0; i<2; i++）   

113.    {   

114.        control[1-i] = sd2300_receive_byte（）; //conctro[1]为控制寄存器

115.1，control[0]为控制寄存器2 

116.        if （i !

= 1）                           //最后一个数据不应答   

117.        {   

118.            sd2300_ack（）;   

119.        }   

120.    }   

121.   

122.    sd2300_no_ack（）;   

123.    sd2300_stop（）;   

124.}   

125.     

126.//修改定时器A小时的寄存器，使之加1   

127.void modify_alarm_hour（ ）   

128.{   

129.    u_char hour, flag;     //flag用来判断是24小时制还是12小时制   

130.    read_alarm（）;   

131.    hour =（ （alarm[0] & 0x30） >> 4）*10 + （ alarm[0] & 0x0f ）;      

132.    read_control（ ）;   

133.    hour++;   

134.    flag = control[0] & 0x20;      

135.    if （flag）   

136.        {   

137.            if （hour == 24）   

138.                            hour = 0;   

139.        }   

140.   

141.    else if （hour ==12）   

142.        {   

143.            hour = 0;   

144.        }      

145.    alarm[0] = （ （0x00|（hour/10））<<4 ） + （ 0x00|（hour%10） ）;   

146.}      

147.//修改定时器A分寄存器中的数据，使之加1   

148.void modify_alarm_minute（void）   

149.{   

150.    u_char minute;//   

151.    read_alarm（）;   

152.    minute = （ （alarm[1] & 0x70） >> 4）*10 + （alarm[1] & 0x0f）;   

153.    minute++;   

154.    if （minute == 60 ）   

155.        {   

156.            minute = 0;   

157.        }   

158.   alarm[1] = （ （ 0x00|（minute/10） ）<<4 ） + （ 0x00|（minute%10） ）;   

159.}   

160.   //修改小时寄存器（2h）中的数据，使之加1   

161.void modify_time_hour（void）   

162.{   

163.    u_char hour, flag;         //flag用来判断是24小时制还是12小时制   

164.    sd2300_read_date（）;   

165.    hour =（ （date[4] & 0x30） >> 4）*10 + （ date[4] & 0x0f ）;     

166.    hour++;      

167.    read_control（ ）;   

168.    flag = control[0] & 0x20;      

169.    if （flag）   

170.        {   

171.            if （hour == 24）   

172.                            hour = 0;   

173.        }      

174.    else if （hour ==12）   

175.        {   

176.            h