时间温度控制系统（128*64LCD+ds1302+ds18b20）

主要功能：
           温度计 时钟 闹铃 密码锁 篮球器 计算器 温度控制 键盘锁 系统设置等。

时间温度控制系统原理图及元器件.pdf (312.48 KB, 下载次数: 216)

2014-12-16 16:55 上传

点击文件名下载附件
下载积分: 黑币 -5

时间温度控制系统源代码.zip (225.76 KB, 下载次数: 197)

2014-12-16 16:55 上传

点击文件名下载附件
下载积分: 黑币 -5

下面是源代码

1. /**************************************************************************************
   
2. 程序名称：
   
3.            时间 温度控制系统（128*64LCD+ds1302+ds18b20）
   
4. 主要功能：
   
5.            温度计 时钟 闹铃 密码锁 篮球器 计算器 温度控制 键盘锁 系统设置等。
   
6. 主要说明：
   
7.            程序全部定义在一个C文件中。
   
8. 作者：   
   
9.            JZHG
   
10. 时间：   
    
11.            2011.12.19
    
12. 版本：   
    
13.            JZHG-V1.0
    
14. /**************************************************************************************/
    
15. #include<reg52.h>
    
16. #include<intrins.h>
    
17. #define uchar unsigned char
    
18. #define uint unsigned int
    
19. #define time_count 0x3cb0 //时间计数
    
20. #define close 1           //开始标志
    
21. #define open 0            //结束标志
    
22. #define keyboard P1       //键盘数据口
    
23. /*****************状态控制及温感器总线定义*****************************/
    
24. 
    
25. sbit b20_io=P0^0; //ds18b20总线
    
26. sbit pw_oc=P0^4;  //密码锁开启控制灯
    
27. sbit buzzer=P0^5; //喇叭端口
    
28. sbit lcd_bl=P0^6;  //背光控制端口
    
29. sbit als_th=P3^6;  //上限温度警报
    
30. sbit als_tl=P3^7;  //下限温度警报
    
31. 
    
32. /******************LCD12864定义**************************/
    
33. 
    
34. #define lcd_data P2//lcd数据口
    
35. #define comm 0     //lcd指令
    
36. #define dat  1     //lcd数据
    
37. sbit lcd_rst=P0^7; //lcd复位
    
38. sbit lcd_e  =P3^0; //lcd使能
    
39. sbit lcd_rw =P3^1; //lcd读写
    
40. sbit lcd_rs =P3^2; //lcd数据指令
    
41. sbit busy   =P2^7; //忙碌位
    
42. 
    
43. /*****************ds1302定义**************************/
    
44. 
    
45. sbit d02_rst =P0^1;  //ds1302使能
    
46. sbit d02_data=P0^2;  //ds1302数据
    
47. sbit d02_sclk=P0^3;  //ds1302时钟
    
48. 
    
49. #define d02_wrc    0x8e //ds1302读写控制
    
50. #define d02_year   0x8c //年
    
51. #define d02_weeks  0x8a //星期
    
52. #define d02_month  0x88 //月
    
53. #define d02_day    0x86 //日
    
54. #define d02_hour   0x84 //时
    
55. #define d02_minute 0x82 //分
    
56. #define d02_second 0x80 //秒
    
57. #define d02_signs  0xc0 //系统状态（记录设计标记）
    
58. #define d02_passw  0xc2 //密码寄存器首位（有3位下位地址加2，初始值为741456）
    
59. #define d02_alm    0xc8 //闹铃时间小时位（下位为分钟下位加2）
    
60. #define d02_temp   0xcc //温度上限警报（有两位下位加2）
    
61. #define d02_initsi 0xd4 //1302初始化标志（为0xb4,说明已经初始化）
    
62. #define ret_ds1302()   d02_rst=0;d02_sclk=0;d02_rst=1 //1302读写复位
    
63. #define end_ds1302()   d02_sclk=1;d02_rst=0           //1302读写结束
    
64. 
    
65. /*================================= 全局变量定义 ==================================*/
    
66. 
    
67. 
    
68. typedef struct          // 定义时间类型
    
69. {
    
70.   uchar hour;
    
71.   uchar minute;
    
72.   uchar second;
    
73. }time;
    
74. 
    
75. typedef struct          // 定义日期类型
    
76. {
    
77.   uchar year;
    
78.   uchar month;
    
79.   uchar day;
    
80.   uchar week;
    
81. }date;
    
82. 
    
83. typedef union           // 定义温度类型
    
84. {
    
85.   int temp_data;
    
86.   uchar t_data[2];
    
87. }trdata;
    
88. 
    
89. trdata  bdata  temp;             // 温度警报值暂存  
    
90. date    idata  today={'8',1,1,1};    // 日期暂存
    
91. time    idata  now={0x12,0,0} , save_time={0x12,0,0};
    
92.               // 时间暂存(now是读出时间暂存 save_time上一时间暂存)
    
93. uchar   idata  time_tick=20,time_tick1=20,alarm_time[2],als_temp[2],
    
94.               // T0中断数,     T1中断数,     闹铃时间,   警报温度
    
95.                bl_delay=15,temp_delay=5,opera[2][12],resu[12],
    
96.               // 背光时间,  温度更新时间, 计算器数据寄存, 结果寄存
    
97.                i,j,save1,temp_min=0;
    
98.                // 计算器i/j下标，中间暂存,温度更新（分）
    
99. 
    
100. 
     
101. 
     
102. uchar  bdata   signs=0;      // 系统标记寄存器
     
103.   sbit bl1=signs^7;          // bl1,bl0背光选择位(00 延时,01 常开,10 关闭)
     
104.   sbit bl0=signs^6;         
     
105.   sbit di1=signs^5;          // di1,di0显示模式(00模式1,01模式2,10模式3)
     
106.   sbit di0=signs^4;         
     
107.   sbit meu=signs^3;          // 菜单显示方式(0 图片,1 文字)
     
108.   sbit keb=signs^2;          // 键盘锁(0 无锁,1加锁)
     
109.   sbit alm=signs^1;          // 闹钟启动位(0 关闭,1开启)
     
110.   sbit als=signs^0;          // 报警启动位(0 启动,1关闭)
     
111. 
     
112. 
     
113. 
     
114. uint   bdata   run_signs=0;     // 运行标记寄存器
     
115.   sbit ds18b20=run_signs^0;     // 温感器存在标记(0不存在，1存在)
     
116.   sbit temp_pn=run_signs^1;     // 温度正负号标记(0正，1负)
     
117.   sbit temprun=run_signs^2;     // 温感器运行标记(0否，1启动)
     
118.   sbit nba_tim=run_signs^3;     // 篮球计时器标记(0关闭，1启动)
     
119.   sbit adju_si=run_signs^4;     // 数字更改连续标记(1连续)
     
120.   sbit cal_del=run_signs^5;     // 计算器显示点标记（0没有显示）
     
121.   sbit cal_run=run_signs^6;     // 计算完毕标记（1有效）
     
122.   sbit oth_run=run_signs^7;     // 其他标记
     
123.   sbit alm_run=run_signs^8;     // 闹钟时间到达标记（1有效）
     
124.   sbit dis_sig=run_signs^9;     // 显示时间标记（1有效）
     
125.   sbit lock_op=run_signs^10;    // 关锁时间到标记（1有效）
     
126.   sbit b20time=run_signs^11;    // 温感器重新读温度标记(1有效)
     
127.   sbit t0_isr =run_signs^12;    // TO中断标记（1有效(1s)
     
128.   sbit thl_als=run_signs^13;    // 温度警报标记
     
129.   sbit init_d2=run_signs^14;    // 模式2初始显示
     
130.   sbit buzstop=run_signs^15;    // 蜂鸣器停止标记
     
131. 
     
132. 
     
133. 
     
134. 
     
135. /*================================= 字体显示代码 ==================================*/
     
136. 
     
137. uchar code weeks[7][2]={"一","二","三","四","五","六","日"}; // 星期                //图片中文
     
138. uchar code menu_cn[6][8]={"调    整","工    具","设    置","保    密","版    本","退    出"};
     
139. uchar code menu_cn_2[6][6]={"调  整","工  具","设  置","保  密","版  本","退  出"};// 菜单文字
     
140. uchar code selected[2][16]={{"进入【      】\x04 "},{"设置【    】\x10 \x04 "}}; // 选框
     
141. uchar code secrets_menu[4][6]={"开  锁","更  改","初始化","退  出"};           // 保密菜单中文
     
142. uchar code tool_menu[5][6]={"计算器","温度计","闹  铃","篮球器","退  出"};     // 工具菜单中文
     
143. uchar code char_num[10]={"0123456789"};  // 数字显示代码                             // 每月天数
     
144. uchar code dayofmonth[12]={0x31,0x28,0x31,0x30,0x31,0x30,0x31,0x31,0x30,0x31,0x30,0x31};
     
145. uchar code key_code[]={0xD7,0x7E,0x7D,0x7B,0xBE,0xBD,0xBB,0xDE,0xDD,0xDB,0xB7,0x77,0xEE,0xED,0xEB,0xE7};
     
146. uchar code ksp[4]={0x7F,0xBF,0xDF,0xEF};     // 按键扫描代码
     
147. uchar code tool_cal[4][2]={"+ ","- ","* ","/ "}; // 运算符号
     
148. uchar code alm_sign[2][2]={"关","开"};           // 闹铃开关
     
149. uchar code set_bl_dm[2][3][4]={{"30秒","常开","关闭"},{"模01","模02","模03"}};
     
150. uchar code set_mka[3][2][4]={{"图片","文字"},{"解锁","加锁"},{"开启","关闭"}};
     
151. uchar code nba_oppo[8][2]={"红","白","蓝","绿","紫","灰","黄","黑"};
     
152. uchar code set_menu[6][4]={"背光","显示","菜单","键盘","警报","退出"};
     
153. 
     
154. 
     
155. uchar code version[9][16]={   // 版本信息
     
156.                             {"湖南科技经贸学院"},
     
157.                             {"电子信息工程学院"},
     
158.                             {"11年电子技能大赛"},
     
159.                             {"    —10电子01班"},
     
160.                             {"作者：蒋志高    "},
     
161.                             {"版本：JZHG-V1.0 "},
     
162.                             {"    2011/12/19  "},
     
163.                             {"谢谢你的使用！  "},
     
164.                             {"        (ok)\x10"},
     
165.                                     };
     
166. 
     
167. 
     
168. uchar code timer_tips[12][16]={ // 篮球器使用说明
     
169.                             {"使用方法：      "},
     
170.                             {"  (+)(-)与(*)(/)"},
     
171.                             {"分别是两方的分数"},
     
172.                             {"加与减,(7)键回退"},
     
173.                             {"一秒,(8)键24秒复"},
     
174.                             {"位,(9)键暂停与开"},
     
175.                             {"始；暂停状态下："},
     
176.                             {"按两次(OK)键可返"},
     
177.                             {"回时钟模式-2界面"},
     
178.                             {"，(OK)键返回程序"},
     
179.                             {"界面,(./S)键两次"},
     
180.                             {"退出程序.      \x1f"}};
     
181. 
     
182. 
     
183. 
     
184. /*================================= 操作导航代码 ==================================*/
     
185. 
     
186. 
     
187. typedef struct          // 定义主菜单操作索引
     
188. {
     
189.   uchar shaft_num;
     
190.   uchar left_num;
     
191.   uchar right_num;
     
192. }menu_index;
     
193. 
     
194. typedef struct          // 定义导航更改索引
     
195. {
     
196.   uchar lnum;
     
197.   uchar rnum;
     
198. }index;
     
199. 
     
200. menu_index code index_m[6]={{3,5,1},{4,0,2},{5,1,3},{0,2,4},{1,3,5},{2,4,0}}; // 菜单导航
     
201. index code index_t[6]={{4,1},{0,2},{1,3},{2,4},{3,0}};       // 工具导航
     
202. index code index_p[5]={{3,1},{0,2},{1,3},{2,0}};             // 保密导航
     
203. index code index_s[6]={{5,1},{0,2},{1,3},{2,4},{3,5},{4,0}}; // 设置导航
     
204. index code index_a[7]={{0x81,0x91},{0x83,0x91},{0x85,0x91},{0x89,0x81},
     
205.                         {0x8b,0x81},{0x8d,0x81},{0x8f,0x91}};       // 调整下的坐标
     
206. index code index_temp_set[3]={{0x8b,0x81},{0x8b,0x91},{0x8f,0x91}}; // 温度设定下的坐标
     
207. index code index_alm[3]={{0x8c,0x81},{0x8e,0x81},{0x8f,0x91}};      // 闹铃更改坐标
     
208. index code index_cal[3]={{0x86,0x90},{0x8e,0x80},{0x8e,0x90}};      // 计算器操作坐标
     
209. uchar code index_nba[4]={0x93,0x97,0x8b,0x8f};                      // 篮球器设置导航
     
210. 
     
211. 
     
212. 
     
213. 
     
214. 
     
215. /*========================== 菜单图片（宽度x高度=32*24）=============================*/
     
216. 
     
217. uchar code menu_pic[6][96]={
     
218.     {// 调整
     
219.      0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x00,0x00,0x02,
     
220.      0x40,0x00,0x00,0x82,0x47,0xFF,0xE1,0xC2,0x47,0xFF,0xF3,0xE2,0x47,0x38,0x68,0x02,
     
221.      0x46,0xDF,0x68,0x82,0x46,0xDF,0x69,0xC2,0x46,0xDE,0xE8,0x82,0x46,0xDD,0xE8,0x02,
     
222.      0x46,0xDD,0xE8,0x02,0x47,0x3D,0xE8,0x02,0x47,0xFF,0xE8,0x02,0x47,0xFF,0xE9,0xC2,
     
223.      0x42,0x00,0x18,0x02,0x41,0xFF,0xF3,0xE2,0x40,0x00,0x01,0xC2,0x40,0x00,0x00,0x82,
     
224.      0x40,0x00,0x00,0x02,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
     
225.    
     
226.     {// 工具                           
     
227.      0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x00,0x03,0x82,
     
228.      0x41,0xF0,0x07,0xC2,0x43,0xFF,0xCF,0xE2,0x47,0x3F,0xFE,0x02,0x47,0x3F,0xFE,0x02,
     
229.      0x43,0xFF,0xCF,0xE2,0x41,0xF0,0x0F,0xC2,0x40,0x00,0x03,0x82,0x40,0x00,0x00,0x02,
     
230.      0x40,0x00,0x03,0xC2,0x40,0x00,0x03,0xC2,0x41,0x80,0x01,0x82,0x43,0xFF,0xF3,0xC2,
     
231.      0x47,0xFF,0xFF,0xE2,0x47,0xFF,0xFF,0xE2,0x43,0xFF,0xF3,0xC2,0x41,0x80,0x01,0x82,
     
232.      0x40,0x00,0x01,0x82,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
     
233.    
     
234.     {// 设置
     
235.      0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x43,0x18,0x00,0x02,
     
236.      0x44,0xA4,0x0E,0x02,0x44,0xA4,0x1F,0x02,0x43,0x24,0x3F,0x02,0x40,0x00,0x7F,0x02,
     
237.      0x40,0xF0,0xFC,0x02,0x43,0xF9,0xF0,0x02,0x43,0x03,0xE0,0x02,0x46,0x77,0x80,0x02,
     
238.      0x46,0x7F,0x00,0x02,0x46,0x7E,0x00,0x02,0x46,0x7C,0x00,0x02,0x47,0x3D,0x00,0x02,
     
239.      0x43,0x1D,0x81,0x22,0x43,0x81,0xB2,0x42,0x41,0xC3,0x4F,0xE2,0x40,0xFE,0x4A,0x42,
     
240.      0x40,0x3C,0x32,0x42,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
     
241.    
     
242.     {// 保密
     
243.      0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0xFC,0x03,0x02,
     
244.      0x41,0xFE,0x1F,0x02,0x43,0x87,0x03,0x82,0x43,0x03,0x03,0x02,0x43,0x03,0x03,0x02,
     
245.      0x43,0x03,0x0F,0x02,0x43,0x03,0x03,0x02,0x43,0x03,0x03,0x02,0x47,0xFF,0x83,0x02,
     
246.      0x47,0xFF,0x83,0x02,0x47,0xCF,0x83,0x02,0x47,0x87,0x83,0x02,0x47,0xCF,0x83,0x02,
     
247.      0x47,0xCF,0x87,0x82,0x47,0xCF,0x8F,0xC2,0x47,0xCF,0x9C,0xE2,0x47,0xFF,0x8F,0xC2,
     
248.      0x43,0xFF,0x07,0x82,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
     
249.    
     
250.     {// 版本
     
251.      0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x00,0x00,0x02,
     
252.      0x40,0x0F,0x00,0x62,0x40,0x1D,0x80,0xF2,0x40,0x38,0x41,0xF2,0x40,0x70,0x23,0xE2,
     
253.      0x40,0xE2,0x17,0xC2,0x41,0xE4,0x4F,0x82,0x41,0xF0,0x9F,0x02,0x41,0x59,0x16,0x02,
     
254.      0x42,0x4C,0x1D,0x02,0x42,0x46,0x20,0x82,0x42,0x47,0x00,0x42,0x44,0x43,0x80,0xC2,
     
255.      0x44,0x44,0xC1,0xC2,0x44,0xC8,0x63,0x82,0x45,0x50,0x37,0x02,0x46,0x60,0x1E,0x02,
     
256.      0x40,0x40,0x0C,0x02,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
     
257.    
     
258.     {// 退出
     
259.      0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x40,0xFF,0xE2,
     
260.      0x40,0x60,0x80,0x62,0x43,0xF0,0x80,0xA2,0x43,0xF0,0x81,0x22,0x40,0x60,0x82,0x22,
     
261.      0x40,0x40,0x84,0x22,0x40,0x00,0x88,0x22,0x40,0x00,0x88,0x22,0x47,0xFF,0xF8,0x22,
     
262.      0x47,0xFF,0xF8,0x22,0x46,0x2A,0x2A,0x22,0x46,0xE3,0x78,0x22,0x46,0x77,0x78,0x22,
     
263.      0x46,0xE3,0x78,0x62,0x46,0x2A,0x38,0x82,0x47,0xFF,0xF9,0x02,0x47,0xFF,0xFA,0x02,
     
264.      0x40,0x00,0x0C,0x02,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00,}};
     
265. 
     
266. 
     
267. 
     
268. 
     
269. /*================ 显示模式2数字及温度符号图片（宽度x高度=16*32）=====================*/
     
270. 
     
271. uchar code mode_2num[11][64]={
     
272.     {// 图片数字0
     
273.      0x00,0x00,0x3F,0xFC,0x5F,0xFA,0x6F,0xF6,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
     
274.      0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x60,0x06,0x40,0x02,0x00,0x00,
     
275.      0x40,0x02,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
     
276.      0x70,0x0E,0x70,0x0E,0x70,0x0E,0x6F,0xF6,0x5F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
     
277.    
     
278.     {// 图片数字1
     
279.      0x00,0x00,0x00,0x20,0x00,0x60,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,
     
280.      0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0x60,0x00,0x20,0x00,0x00,0x00,0x20,
     
281.      0x00,0x60,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,
     
282.      0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0x60,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00},
     
283.    
     
284.     {// 图片数字2
     
285.      0x00,0x00,0x3F,0xFC,0x1F,0xFA,0x0F,0xF6,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
286.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x1F,0xFA,0x3F,0xFC,
     
287.      0x5F,0xF8,0x60,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,
     
288.      0x70,0x00,0x70,0x00,0x70,0x00,0x6F,0xF8,0x5F,0xFC,0x3F,0xFE,0x00,0x00,0x00,0x00},
     
289.    
     
290.     {// 图片数字3
     
291.      0x00,0x00,0x7F,0xFC,0x3F,0xFA,0x1F,0xF6,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
292.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x1F,0xFA,0x3F,0xFC,
     
293.      0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
294.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x1F,0xF6,0x3F,0xFA,0x7F,0xFC,0x00,0x00,0x00,0x00},
     
295.    
     
296.     {// 图片数字4
     
297.      0x00,0x00,0x40,0x02,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
     
298.      0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x60,0x06,0x5F,0xFA,0x3F,0xFC,
     
299.      0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
300.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x00,0x02,0x00,0x00,0x00,0x00},
     
301.    
     
302.     {// 图片数字5
     
303.      0x00,0x00,0x3F,0xFC,0x5F,0xF8,0x6F,0xF0,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,
     
304.      0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x60,0x00,0x5F,0xF8,0x3F,0xFC,
     
305.      0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
306.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x0F,0xF6,0x1F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
     
307.    
     
308.     {// 图片数字6
     
309.      0x00,0x00,0x3F,0xFC,0x5F,0xF8,0x6F,0xF0,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,
     
310.      0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x60,0x00,0x5F,0xF8,0x3F,0xFC,
     
311.      0x5F,0xFA,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
     
312.      0x70,0x0E,0x70,0x0E,0x70,0x0E,0x6F,0xF6,0x5F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
     
313.    
     
314.     {// 图片数字7
     
315.      0x00,0x00,0x7F,0xFC,0x3F,0xFA,0x1F,0xF6,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
316.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x00,0x02,0x00,0x00,
     
317.      0x00,0x02,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
318.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x00,0x02,0x00,0x00,0x00,0x00},
     
319.    
     
320.     {// 图片数字8
     
321.      0x00,0x00,0x3F,0xFC,0x5F,0xFA,0x6F,0xF6,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
     
322.      0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x60,0x06,0x5F,0xFA,0x3F,0xFC,
     
323.      0x5F,0xFA,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
     
324.      0x70,0x0E,0x70,0x0E,0x70,0x0E,0x6F,0xF6,0x5F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
     
325.    
     
326.     {// 图片数字9
     
327.      0x00,0x00,0x3F,0xFC,0x5F,0xFA,0x6F,0xF6,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
     
328.      0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x60,0x06,0x5F,0xFA,0x3F,0xFC,
     
329.      0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
     
330.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x1F,0xF6,0x3F,0xFA,0x7F,0xFC,0x00,0x00,0x00,0x00},
     
331.    
     
332.     {// 温度符号
     
333.      0x00,0x00,0x00,0x00,0x70,0xE0,0x53,0xF0,0x77,0xFA,0x0E,0x0E,0x0C,0x06,0x18,0x06,
     
334.      0x18,0x02,0x38,0x02,0x30,0x00,0x30,0x00,0x70,0x00,0x60,0x00,0x60,0x00,0x60,0x00,
     
335.      0x60,0x00,0x60,0x00,0x70,0x00,0x30,0x00,0x30,0x00,0x38,0x00,0x18,0x02,0x18,0x02,
     
336.      0x0C,0x06,0x0E,0x06,0x07,0x0E,0x03,0xFA,0x00,0xF0,0x00,0x60,0x00,0x00,0x00,0x00}};
     
337. 
     
338. 
     
339. 
     
340. 
     
341. 
     
342. /*===================== 显示模式3数字图片（宽度x高度=24*32）=========================*/
     
343. 
     
344. uchar code mode_3num[10][96]={
     
345.     {// 图片数字0
     
346.      0x00,0x7E,0x00,0x01,0xE7,0x80,0x03,0xC3,0xC0,0x07,0x81,0xE0,0x0F,0x80,0xF0,0x0F,
     
347.      0x00,0xF0,0x1F,0x00,0xF8,0x1E,0x00,0xF8,0x3E,0x00,0x78,0x3E,0x00,0x7C,0x3E,0x00,
     
348.      0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,
     
349.      0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,
     
350.      0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x78,0x1E,0x00,0xF8,0x1F,0x00,0xF8,0x0F,0x00,
     
351.      0xF0,0x0F,0x81,0xF0,0x07,0x81,0xE0,0x03,0xC3,0xC0,0x01,0xE7,0x80,0x00,0x7E,0x00},
     
352. 
     
353.     {// 图片数字1
     
354.      0x00,0x0C,0x00,0x00,0x1C,0x00,0x00,0x7C,0x00,0x07,0xFC,0x00,0x00,0x3C,0x00,0x00,
     
355.      0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,
     
356.      0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,
     
357.      0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,
     
358.      0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,
     
359.      0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3E,0x00,0x00,0x7F,0x00,0x07,0xFF,0xF0},
     
360.                
     
361.     {// 图片数字2
     
362.      0x00,0xFF,0x00,0x03,0xC7,0xC0,0x07,0x01,0xE0,0x0E,0x00,0xF0,0x1E,0x00,0xF8,0x1E,
     
363.      0x00,0xF8,0x3E,0x00,0x78,0x3E,0x00,0x78,0x3F,0x00,0x78,0x3F,0x00,0x78,0x1F,0x00,
     
364.      0xF8,0x00,0x00,0xF8,0x00,0x00,0xF0,0x00,0x01,0xF0,0x00,0x03,0xE0,0x00,0x03,0xC0,
     
365.      0x00,0x07,0x80,0x00,0x0F,0x00,0x00,0x1E,0x00,0x00,0x3C,0x00,0x00,0x78,0x00,0x00,
     
366.      0xF0,0x00,0x01,0xE0,0x00,0x03,0xC0,0x00,0x07,0x80,0x1C,0x07,0x00,0x1C,0x0E,0x00,
     
367.      0x38,0x1C,0x00,0x38,0x3C,0x00,0x78,0x3F,0xFF,0xF8,0x3F,0xFF,0xF8,0x3F,0xFF,0xF8},
     
368. 
     
369.     {// 图片数字3
     
370.      0x00,0xFE,0x00,0x07,0x87,0x80,0x0F,0x03,0xC0,0x1E,0x01,0xE0,0x1E,0x01,0xF0,0x1E,
     
371.      0x01,0xF0,0x1F,0x00,0xF0,0x1F,0x00,0xF0,0x1E,0x00,0xF0,0x00,0x00,0xF0,0x00,0x01,
     
372.      0xF0,0x00,0x01,0xF0,0x00,0x03,0xE0,0x00,0x03,0xC0,0x00,0x0F,0x00,0x00,0xFE,0x00,
     
373.      0x00,0x07,0x80,0x00,0x01,0xE0,0x00,0x00,0xF0,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,
     
374.      0x00,0x78,0x00,0x00,0x7C,0x1E,0x00,0x7C,0x3F,0x00,0x7C,0x3F,0x00,0x7C,0x3F,0x00,
     
375.      0x78,0x3E,0x00,0xF8,0x1E,0x00,0xF0,0x0F,0x01,0xE0,0x07,0x87,0xC0,0x01,0xFF,0x00},
     
376. 
     
377.     {// 图片数字4
     
378.      0x00,0x03,0xC0,0x00,0x03,0xC0,0x00,0x07,0xC0,0x00,0x0F,0xC0,0x00,0x0F,0xC0,0x00,
     
379.      0x1F,0xC0,0x00,0x3F,0xC0,0x00,0x3F,0xC0,0x00,0x77,0xC0,0x00,0x77,0xC0,0x00,0xE7,
     
380.      0xC0,0x01,0xC7,0xC0,0x01,0xC7,0xC0,0x03,0x87,0xC0,0x07,0x07,0xC0,0x07,0x07,0xC0,
     
381.      0x0E,0x07,0xC0,0x1E,0x07,0xC0,0x1C,0x07,0xC0,0x38,0x07,0xC0,0x38,0x07,0xC0,0x7F,
     
382.      0xFF,0xFE,0x7F,0xFF,0xFE,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,
     
383.      0xC0,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,0xE0,0x00,0x7F,0xFE},
     
384. 
     
385.     {// 图片数字5
     
386.      0x0F,0xFF,0xF8,0x0F,0xFF,0xF8,0x0F,0xFF,0xF8,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,
     
387.      0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,
     
388.      0x00,0x0E,0x7F,0x00,0x0D,0xFF,0xC0,0x0F,0xC3,0xE0,0x1F,0x01,0xF0,0x1E,0x00,0xF8,
     
389.      0x1E,0x00,0xF8,0x00,0x00,0x78,0x00,0x00,0x7C,0x00,0x00,0x7C,0x00,0x00,0x7C,0x00,
     
390.      0x00,0x7C,0x1E,0x00,0x7C,0x3F,0x00,0x7C,0x3F,0x00,0x78,0x3F,0x00,0x78,0x3E,0x00,
     
391.      0xF8,0x1E,0x00,0xF0,0x1E,0x01,0xF0,0x0E,0x01,0xE0,0x07,0x87,0xC0,0x00,0xFF,0x00},
     
392. 
     
393.     {// 图片数字6
     
394.      0x00,0x3F,0xC0,0x00,0xF1,0xE0,0x03,0xC1,0xF0,0x07,0x81,0xF8,0x07,0x01,0xF8,0x0F,
     
395.      0x00,0xF0,0x1F,0x00,0x00,0x1E,0x00,0x00,0x1E,0x00,0x00,0x3E,0x00,0x00,0x3E,0x00,
     
396.      0x00,0x3E,0x00,0x00,0x3E,0x3F,0x80,0x3E,0xFF,0xE0,0x3F,0xE3,0xF0,0x3F,0x80,0xF8,
     
397.      0x3F,0x00,0xF8,0x3F,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x3C,0x3E,
     
398.      0x00,0x3C,0x3E,0x00,0x3C,0x3E,0x00,0x3C,0x3E,0x00,0x7C,0x1E,0x00,0x7C,0x1F,0x00,
     
399.      0x78,0x0F,0x00,0x78,0x0F,0x80,0xF0,0x07,0xC0,0xE0,0x03,0xE3,0xC0,0x00,0xFF,0x00},
     
400. 
     
401.     {// 图片数字7
     
402.      0x1F,0xFF,0xFC,0x1F,0xFF,0xFC,0x1F,0xFF,0xF8,0x1F,0x00,0x38,0x1C,0x00,0x70,0x1C,
     
403.      0x00,0xE0,0x38,0x00,0xE0,0x38,0x01,0xC0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x03,
     
404.      0x80,0x00,0x07,0x80,0x00,0x07,0x00,0x00,0x0F,0x00,0x00,0x0E,0x00,0x00,0x1E,0x00,
     
405.      0x00,0x1E,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x7C,0x00,0x00,
     
406.      0x78,0x00,0x00,0x78,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,
     
407.      0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0x78,0x00},
     
408. 
     
409.     {// 图片数字8
     
410.      0x00,0xFF,0x00,0x07,0xC3,0xC0,0x0F,0x00,0xE0,0x1E,0x00,0xF0,0x1E,0x00,0x78,0x3C,
     
411.      0x00,0x78,0x3C,0x00,0x78,0x3C,0x00,0x7C,0x3E,0x00,0x78,0x3E,0x00,0x78,0x1F,0x00,
     
412.      0x78,0x1F,0x80,0xF0,0x0F,0xE1,0xE0,0x07,0xFB,0xC0,0x01,0xFF,0x80,0x01,0xFF,0x80,
     
413.      0x07,0xBF,0xC0,0x0F,0x0F,0xE0,0x1E,0x03,0xF0,0x3E,0x01,0xF8,0x3C,0x00,0xF8,0x3C,
     
414.      0x00,0x7C,0x7C,0x00,0x7C,0x78,0x00,0x3C,0x78,0x00,0x3C,0x7C,0x00,0x3C,0x3C,0x00,
     
415.      0x78,0x3C,0x00,0x78,0x1E,0x00,0x70,0x0F,0x00,0xE0,0x07,0xC3,0xC0,0x01,0xFF,0x00},
     
416. 
     
417.     {// 图片数字9
     
418.      0x01,0xFE,0x00,0x07,0xC7,0x80,0x0F,0x01,0xE0,0x1E,0x01,0xE0,0x1E,0x00,0xF0,0x3E,
     
419.      0x00,0xF8,0x3C,0x00,0x78,0x3C,0x00,0x78,0x7C,0x00,0x7C,0x7C,0x00,0x7C,0x7C,0x00,
     
420.      0x7C,0x7C,0x00,0x7C,0x7C,0x00,0x7C,0x3C,0x00,0xFC,0x3E,0x00,0xFC,0x3E,0x01,0xFC,
     
421.      0x1F,0x03,0xFC,0x1F,0x8F,0xFC,0x0F,0xFF,0x7C,0x03,0xFC,0x7C,0x00,0x00,0x7C,0x00,
     
422.      0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF0,0x00,0x01,0xF0,0x0F,0x01,
     
423.      0xE0,0x1F,0x01,0xE0,0x1F,0x03,0xC0,0x1F,0x07,0x80,0x0F,0x9F,0x00,0x03,0xFC,0x00}};
     
424. 
     
425. 
     
426. 
     
427. 
     
428. /*========================== 标记及点图片（宽度x高度=16*16）===========================*/
     
429. 
     
430. 
     
431. uchar code running[7][32]={
     
432.      {// 警报标记16*16
     
433.       0x00,0x00,0x00,0x39,0x00,0x7B,0x00,0xFE,0x01,0xDC,0x0F,0x98,0x0F,0x18,0x0C,0x1F,
     
434.       0x0C,0x1F,0x0F,0x18,0x0F,0x98,0x01,0xDC,0x00,0xFE,0x00,0x7B,0x00,0x39,0x00,0x00,},
     
435.      {// 闹铃开启标记16*16
     
436.       0x00,0x00,0x00,0x40,0x00,0xE0,0x01,0xB0,0x01,0xB0,0x03,0x18,0x03,0x18,0x06,0x0C,
     
437.       0x0C,0x06,0x0C,0xE6,0x1B,0x1B,0x0C,0x06,0x06,0x0C,0x03,0xF8,0x00,0xE0,0x00,0x00},
     
438.      {// 键盘锁标记16*16
     
439.       0x00,0x00,0x01,0xF8,0x03,0xFC,0x03,0x0C,0x03,0x0C,0x03,0x0C,0x03,0xFC,0x06,0x96,
     
440.       0x0E,0xA7,0x0E,0xC7,0x0E,0xA7,0x0E,0x97,0x07,0xFE,0x03,0xFC,0x01,0xF8,0x00,0x00,},
     
441.      {// 温度计标记16*16
     
442.       0x00,0x00,0x1F,0xF8,0x1F,0xF8,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,
     
443.       0x01,0x90,0x01,0x98,0x01,0x9C,0x01,0x9E,0x01,0x9C,0x00,0x18,0x00,0x10,0x00,0x00},
     
444.      {// 模式3点16*16
     
445.       0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,
     
446.       0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
     
447.      {// 模式2点16*16
     
448.       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,
     
449.       0x03,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},   
     
450.      {// 篮球器运行标记16*16
     
451.       0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0xF8,0x1F,0xF8,0x01,0x80,0x01,0x80,0x01,0x90,
     
452.       0x01,0x98,0x01,0x9C,0x01,0x9E,0x01,0x9C,0x01,0x98,0x01,0x90,0x00,0x00,0x00,0x00}};
     
453. 
     
454. 
     
455. /*========================== 菜单按钮图片（宽度x高度=16*8）============================*/
     
456. 
     
457. uchar code menu_key[]=
     
458.      {//菜单按钮
     
459.       0x7F,0xFE,0x81,0x81,0x83,0xC1,0x87,0xE1,0x8F,0xF1,0x9F,0xF9,0x80,0x01,0x7F,0xFE
     
460.      };
     
461. 
     
462. 
     
463. 
     
464. 
     
465. 
     
466. /*=====================================================================================
     
467. 函数名称：定时器中断处理与初始化，延时
     
468. 功能描述：时钟更新、篮球器计时
     
469. 全局变量：time_tick、time_tick1、resu[2]、resu[3]、resu[4]、temp_delay、temp_min
     
470. 参数说明：无
     
471. 返回说明：t0_isr(中断标记)、b20time(温度更新标记)
     
472. 设 计 人：JZHG
     
473. 版    本：1.0
     
474. 说    明：
     
475. ======================================================================================*/
     
476. 
     
477. 
     
478. /*延时（一次10个机器周期不等） 参数格式：延时数*/
     
479. void delay(unsigned int det)
     
480. {
     
481.   while(det--);
     
482. }
     
483. 
     
484. 
     
485. 
     
486. /*1s延时*/
     
487. void delay_pw()
     
488. {
     
489.   delay(60000);
     
490.   delay(60000);
     
491. }
     
492. 
     
493. 
     
494. /*6个周期  6us */
     
495. void  delay_b20(uchar n)
     
496. {  
     
497.   while(n--);
     
498. }
     
499. 
     
500. 
     
501. 
     
502. /*主时钟中断处理*/
     
503. void time0_isr(void) interrupt  1  using 1
     
504. {
     
505.   TR0=0;
     
506.   TL0=(time_count&0x00FF);
     
507.   TH0=(time_count>>8);
     
508.   TR0=1;
     
509.   if(--time_tick)  return;
     
510.   time_tick=20;
     
511.   t0_isr=1;
     
512.   if(nba_tim&!oth_run)     // 当在篮球器界面时 nba_tim==1、oth_run==0
     
513.   {
     
514.     if(resu[3]==0)
     
515.     {
     
516.       resu[3]=59;
     
517.       if(resu[2]>0) resu[2]--;
     
518.     }
     
519.     else resu[3]--;
     
520.     if(resu[2]==0&resu[3]==0)  // 比赛时间到后停止
     
521.     {
     
522.       TR0=0;TR1=0;EA=0;
     
523.     }
     
524.     return;
     
525.   }
     
526.   if((++temp_min)==60)    // 实现温度的更新
     
527.   {
     
528.     temp_min=0;
     
529.     temp_delay--;
     
530.     if(temp_delay==0)
     
531.     {
     
532.       b20time=1;temp_delay=5;
     
533.     }
     
534.   }
     
535. }
     
536. 
     
537. 
     
538. /*24时钟中断处理*/
     
539. void time1_isr(void) interrupt  3  using 2
     
540. {
     
541.   TR1=0;
     
542.   TL1=(time_count&0x00FF);
     
543.   TH1=(time_count>>8);
     
544.   TR1=1;
     
545.   if(--time_tick1) return;
     
546.   time_tick1=20;
     
547.   if(resu[4]>0)resu[4]--;     //  篮球器24秒中断
     
548.   t0_isr=1;
     
549.   if(resu[4]==0)
     
550.   { TR0=0;TR1=0;EA=0;}
     
551. }
     
552. 
     
553. 
     
554. /*定时器初始化*/
     
555. void time_init()            
     
556. {
     
557.   EA=0;
     
558.   TR0=0;
     
559.   TR1=0;
     
560.   TMOD=0x11;
     
561.   TL0=(time_count&0x00FF);
     
562.   TH0=(time_count>>8);
     
563.   TL1=(time_count&0x00FF);
     
564.   TH1=(time_count>>8);
     
565.   IE=0;
     
566.   ET0=1;
     
567.   ET1=1;
     
568. }
     
569. 
     
570. 
     
571. 
     
572. /*=====================================================================================
     
573. 函数名称：LCD驱动
     
574. 功能描述：基本驱动（写1个字节、清屏、初始化）
     
575. 全局变量：无
     
576. 参数说明：dat_comm（0：命令 1：数据）,content（数值）
     
577. 返回说明：无返回值
     
578. 设 计 人：JZHG
     
579. 版    本：1.0
     
580. 说    明：
     
581. ======================================================================================*/
     
582. 
     
583. 
     
584. /*检查忙碌位*/
     
585. void chk_busy (void)
     
586. {
     
587.   lcd_data = 0xff;
     
588.   lcd_rs = 0;    // 命令
     
589.   lcd_rw = 1;    // 读
     
590.   lcd_e = 1;
     
591.   while(busy==1);
     
592.   lcd_e = 0;
     
593. }
     
594. 
     
595. 
     
596. /*写LCD 参数格式：0:命令,1:数值 ，数据*/
     
597. void wr_lcd (uchar dat_comm,uchar content)
     
598. {
     
599.   chk_busy ();
     
600.   lcd_rs=dat_comm;
     
601.   lcd_rw = 0;         // 写
     
602.   lcd_data=content;   // 输出数据或命令
     
603.   lcd_e=1;            
     
604.   lcd_e=0;
     
605. }
     
606. 
     
607. 
     
608. /*清绘图*/
     
609. void clrgdram(void)
     
610. {
     
611.   uchar i,j;
     
612.   for(j=0;j<32;j++)
     
613.   {
     
614.     wr_lcd(comm,0x34);
     
615.     wr_lcd(comm,0x80+j);
     
616.     wr_lcd(comm,0x80);
     
617.     wr_lcd(comm,0x30);
     
618.     for(i=0;i<32;i++)
     
619.       wr_lcd(dat,0x00);  // 写入0x00
     
620.    }
     
621.   wr_lcd(comm,0x36);
     
622. }
     
623. 
     
624. 
     
625. /*清除显示*/
     
626. void clear_dis(void)
     
627. {
     
628.   wr_lcd(comm,0x30);
     
629.   wr_lcd(comm,0x01);  // 清屏，地址指针指向00H
     
630.   clrgdram();         // 请绘图RAM
     
631. }
     
632. 
     
633. 
     
634. 
     
635. /*开机LCD初始化*/
     
636. void init_lcd (void)
     
637. {
     
638.   lcd_rst=1;
     
639.   wr_lcd(comm,0x30);  // 30---基本指令动作  
     
640.   wr_lcd(comm,0x06);  // 光标的移动方向
     
641.   wr_lcd(comm,0x0c);  // 开显示，关游标
     
642.   clear_dis();
     
643. }
     
644. 
     
645. 
     
646. 
     
647. 
     
648. 
     
649. /*=====================================================================================
     
650. 函数名称：DS1302驱动
     
651. 功能描述：基本驱动（读写数据、读写日期，时间、初始化）
     
652. 全局变量：无
     
653. 参数说明：w_adder（写地址）,r_adder（读地址），w_data（写入数据）
     
654. 返回说明：返回读取的数据
     
655. 设 计 人：JZHG
     
656. 版    本：1.0
     
657. 说    明：上升沿写入数值，下降沿读出数值，没用设立后背电池充电
     
658. ======================================================================================*/
     
659. 
     
660. 
     
661. /*向1302写数据 参数格式：地址，数据*/
     
662. void w1302(uchar w_adder,uchar w_data)
     
663. {
     
664.   uchar d;
     
665.   ret_ds1302();
     
666.   for(d=0;d<16;d++)
     
667.   {
     
668.     if(d==8) w_adder=w_data;
     
669.     d02_data=(bit)(w_adder&0x01);
     
670.     d02_sclk=0;      // 上升沿
     
671.     w_adder>>=1;
     
672.     d02_sclk=1;
     
673.   }
     
674.   end_ds1302();   
     
675. }
     
676. 
     
677. 
     
678. 
     
679. /*接收1302一个字节的数据 参数格式：读地址*/
     
680. uchar r1302(uchar r_adder)
     
681. {
     
682.   uchar d=0;
     
683.   ret_ds1302();
     
684.   for(d=0;d<8;d++)   // 写地址
     
685.   {
     
686.     d02_data=(bit)(r_adder&0x01);
     
687.     d02_sclk=0;
     
688.     r_adder>>=1;
     
689.     d02_sclk=1;
     
690.   }
     
691.   r_adder=0;
     
692.   for(d=0;d<8;d++)   // 读数据
     
693.   {
     
694.     d02_data=1;
     
695.     d02_sclk=1;      // 下降沿
     
696.     r_adder>>=1;
     
697.     d02_sclk=0;
     
698.     if(d02_data) r_adder|=0x80;
     
699.   }
     
700.   end_ds1302();
     
701.   return(r_adder);
     
702. }
     
703. 
     
704. 
     
705. 
     
706. /*写入时间与日期*/
     
707. void wds1302_time_date(void)
     
708. {
     
709.   w1302(d02_wrc,0x00);               // 写允许
     
710.   w1302(0x90,0xa5);                  // 单二极管2K电阻充电
     
711.   w1302(d02_year,today.year);        // 年
     
712.   w1302(d02_weeks,today.week);       // 星期
     
713.   w1302(d02_month,today.month);      // 月
     
714.   w1302(d02_day,today.day);          // 日
     
715.   w1302(d02_hour,0x7f&now.hour);     // 时
     
716.   w1302(d02_minute,now.minute);      // 分
     
717.   w1302(d02_second,0x7f&now.second); // 秒
     
718.   w1302(d02_wrc,0x80);               // 写禁止
     
719. }
     
720. 
     
721. 
     
722. 
     
723. 
     
724. /*初始化写DS1302 RAM*/
     
725. void init_wds1302_ram(void)
     
726. {
     
727.   w1302(d02_wrc,0x00);
     
728.   w1302(0x90,0xa5);         // 单二极管2K电阻充电
     
729.   w1302(d02_signs,0x00);    // 状态寄存
     
730.   w1302(d02_passw,0x62);    // 密码储存首位
     
731.   w1302(d02_passw+2,0x18);  // 初始值为:741456
     
732.   w1302(d02_passw+4,0x29);  // 密码最后一位
     
733.   w1302(d02_alm,0x12);      // 闹铃时(12小时)
     
734.   w1302(d02_alm+2,0x00);    // 闹铃分(0分)
     
735.   w1302(d02_temp,0xff);     // 温度上限(255为关闭)   
     
736.   w1302(d02_temp+2,0xff);   // 温度下限(关闭)
     
737.   w1302(d02_initsi,0xb4);   // 是否要初始化标记(0xb4为已经初始化)
     
738.   w1302(d02_wrc,0x80);
     
739. }
     
740. 
     
741. /*写DS1302一字节的RAM*/
     
742. void wds1302_data(uchar adder,uchar _data)
     
743. {
     
744.   w1302(d02_wrc,0x00);
     
745.   w1302(adder,_data);
     
746.   w1302(d02_wrc,0x80);
     
747. }
     
748. 
     
749. 
     
750. /*读取日期*/
     
751. void rds1302_date(void)
     
752. {
     
753.   
     
754.   today.year=r1302(d02_year+1);   
     
755.   today.week=r1302(d02_weeks+1);
     
756.   today.month=r1302(d02_month+1);
     
757.   today.day=r1302(d02_day+1);  
     
758. }
     
759. 
     
760. 
     
761. /*读取时间*/
     
762. void rds1302_time(void)
     
763. {
     
764.   now.hour=(r1302(d02_hour+1));
     
765.   now.minute=r1302(d02_minute+1);
     
766.   now.second=r1302(d02_second+1);
     
767.   if(now.hour==alarm_time[0]&&now.minute==alarm_time[1]) alm_run=1;
     
768.   else                                      // 闹铃时间比较
     
769.   {
     
770.     alm_run=0;buzstop=0;buzzer=close;
     
771.   }
     
772. }                       
     
773. 
     
774. /*开机读数据*/
     
775. void rds1302_data(void)
     
776. {
     
777.   signs=r1302(d02_signs+1);
     
778.   alarm_time[0]=r1302(d02_alm+1);
     
779.   alarm_time[1]=r1302(d02_alm+3);
     
780.   als_temp[0]=r1302(d02_temp+1);
     
781.   als_temp[1]=r1302(d02_temp+3);           
     
782. }
     
783. 
     
784. 
     
785. /*DS1302初始化*/
     
786. void init_ds1302(void)
     
787. {
     
788.   wds1302_time_date();
     
789.   init_wds1302_ram();
     
790. }
     
791. 
     
792. 
     
793. /*=====================================================================================
     
794. 函数名称：DS18b20驱动
     
795. 功能描述：基本驱动（读写数据、数据转换、初始化）
     
796. 全局变量：无
     
797. 参数说明：无
     
798. 返回说明：返回读取的数据
     
799. 设 计 人：JZHG
     
800. 版    本：1.0
     
801. 说    明：调试中。。。
     
802. ======================================================================================*/
     
803. 
     
804. 
     
805. 
     
806. /*18B20初始化*/
     
807. void init_ds18b20()
     
808. {
     
809.   b20_io=1;
     
810.   delay_b20(8);
     
811.   b20_io=0;
     
812.   delay_b20(120);       // 延时≥480us
     
813.   b20_io=1;
     
814.   delay_b20(12);        // 拉高为高电平后在15—60us出现低电平，并维持60—240us
     
815.   ds18b20=~b20_io;
     
816.   delay_b20(40);   
     
817. }
     
818. 
     
819. 
     
820. /*向18B20发送一个字节*/
     
821. void send18b20_byte(uchar data_send)
     
822. {
     
823.   uchar d=0;
     
824.   for (d=0;d<8;d++)
     
825.   {
     
826.     b20_io=0;                   // 拉低电平后向总线写入一个位，15us后18B20接收  
     
827.     b20_io=data_send&0x01;      
     
828.     delay_b20(10);              // 延时60us后完成一次
     
829.     b20_io=1;
     
830.     data_send>>=1;              // 下位开始
     
831.   }
     
832. }
     
833. 
     
834. 
     
835. /*从18B20读出温度值 12位分辨率*/  
     
836. void receive18b20(void)
     
837. {
     
838.   uchar n=1,d;
     
839.   for (d=0;d<16;d++)
     
840.   {
     
841.     if(d==8) n=0;
     
842.     b20_io=0;                     // 拉低总线
     
843.     temp.t_data[n]>>=1;            
     
844.     b20_io=1;                     // 拉高总线
     
845.     if(b20_io)                    // 读入总线数值
     
846.       temp.t_data[n]|=0x80;
     
847.     delay_b20(10);                // 等待60us
     
848.   }
     
849. 
     
850. }
     
851. 
     
852. 
     
853. /*数据转化*/
     
854. void conversion_t(void)
     
855. {
     
856.   uchar save=0,save1=0;
     
857.   if(temp.temp_data<0)           // 判断数值符号
     
858.     {temp_pn=1;temp.temp_data=~temp.temp_data+1;}
     
859.   else temp_pn=0;
     
860.   if(temp.t_data[1]&0x01==1) save+=6;       // 小数点后的值转变
     
861.   if((temp.t_data[1]>>1)&0x01==1) save+=12;
     
862.   if((temp.t_data[1]>>2)&0x01==1) save+=25;
     
863.   if((temp.t_data[1]>>3)&0x01==1) save+=50;
     
864.   temp.temp_data>>=4;
     
865.   save1=temp.temp_data&0x00ff;              // 整数部分数值
     
866.   temp.t_data[0]=save1;
     
867.   temp.t_data[1]=save;
     
868.   thl_als=1;
     
869.   if(save1>=(als_temp[0]&0x7f))      // 温度比较
     
870.   {
     
871.     if(!temp_pn||(temp_pn&(als_temp[0]&0x80)!=0)){ als_th=open;als_tl=close;}
     
872.   }
     
873.   else if(save1<(als_temp[1]&0x7f)&&als_temp[1]!=255)
     
874.   {
     
875.     if(!temp_pn||(temp_pn&(als_temp[1]&0x80)!=0)) {als_tl=open;als_th=close;}
     
876.   }
     
877.   else {als_th=als_tl=close;thl_als=0;buzstop=0;buzzer=close;}
     
878. }
     
879. 
     
880. 
     
881. 
     
882. /*18b20功能*/
     
883. void ds18b20_func(void)
     
884. {
     
885.   EA=0;
     
886.   TR0=0;
     
887.   temp.temp_data=0;
     
888.   init_ds18b20();
     
889.   send18b20_byte(0xcc); // 跳过ROM
     
890.   send18b20_byte(0x44); // 温度转换
     
891.   delay_pw();
     
892.   init_ds18b20();
     
893.   send18b20_byte(0xcc);
     
894.   send18b20_byte(0xbe); // 读RAM
     
895.   receive18b20();       // 读取温度值
     
896.   conversion_t();       // 数值转换
     
897.   EA=1;
     
898.   TR0=1;
     
899. }
     
900. 
     
901. 
     
902. 
     
903. /*=====================================================================================
     
904. 函数名称：画面构造
     
905. 功能描述：界面1、2、3，图片菜单，反白，标头，16*16（32）图片
     
906. 全局变量：无
     
907. 参数说明：函数说明
     
908. 返回说明：无
     
909. 设 计 人：JZHG
     
910. 版    本：1.0
     
911. 说    明：X坐标每一格每次16点
     
912. ======================================================================================*/
     
913. 
     
914. 
     
915. /*反白或显示图片 参数格式：(H)8bit数据，(L)8bit数据,X0坐标(16bit)，Y0坐标(1bit),X坐标(16bit)，Y坐标(1bit)*/
     
916. void con_disp (uchar data1,uchar data2,uchar x0,uchar y0,uchar xl,uchar yl)
     
917. {
     
918.   uchar i,j;
     
919.   for(j=0;j<yl;j++)
     
920.   {
     
921.     for(i=0;i<xl;i++)
     
922.     {
     
923.       wr_lcd(comm,0x34);     // 扩展功能
     
924.       wr_lcd(comm,y0+j);     // 写Y坐标
     
925.       wr_lcd(comm,x0+i);     // 写X坐标
     
926.       wr_lcd(comm,0x30);     // 普通功能
     
927.       wr_lcd(dat,data1);
     
928.       wr_lcd(dat,data2);
     
929.     }
     
930.   }
     
931.   wr_lcd(comm,0x36);         // 开绘图显示
     
932. }
     
933. 
     
934. 
     
935. 
     
936. /*显示字体 参数格式: 显示位置(0x80-0x9f),显示个数，显示内容指针*/
     
937. void display_cnasc(uchar dis_bit,uchar num,uchar *cnasc)
     
938. {
     
939.   wr_lcd(comm,0x30);         // 普通功能
     
940.   wr_lcd(comm,dis_bit);      // 写地址
     
941.   while(num>0)
     
942.   {
     
943.     wr_lcd(dat,*(cnasc++));
     
944.     wr_lcd(dat,*(cnasc++));
     
945.     num--;
     
946.   }
     
947. }
     
948. 
     
949. 
     
950. 
     
951. /*导航标头显示*/
     
952. void dis_title(void)
     
953. {
     
954.   display_cnasc(0x80,1,"\x15 ");
     
955.   display_cnasc(0x90,1,"┏");
     
956.   display_cnasc(0x97,1,"┓");
     
957.   display_cnasc(0x98,1,"┗");
     
958.   display_cnasc(0x9f,1,"┛");
     
959.   display_cnasc(0x92,1,"\x1e ");
     
960.   display_cnasc(0x9a,1,"\x1f ");
     
961.   con_disp(0xff,0xff,0x80,0x80,3,16);
     
962.   con_disp(0xef,0xef,0x83,0x80,1,16);
     
963.   con_disp(0xde,0xf7,0x84,0x80,1,16);
     
964.   con_disp(0x76,0xdb,0x85,0x80,1,16);
     
965.   con_disp(0x55,0x55,0x86,0x80,1,16);
     
966.   con_disp(0x55,0x55,0x87,0x80,1,16);   
     
967. }
     
968. 
     
969. 
     
970. /*图片显示标头*/
     
971. void dis_title_pic(void)
     
972. {
     
973.   display_cnasc(0x80,2,"〓〓");
     
974.   display_cnasc(0x86,2,"〓〓");
     
975. }
     
976. 
     
977. 
     
978. /*功能实现显示标头*/
     
979. void dis_title_e(void)
     
980. {
     
981.   display_cnasc(0x80,1," \x15");
     
982.   con_disp(0xff,0xff,0x80,0x80,1,16);
     
983.   con_disp(0xff,0xc7,0x81,0x80,1,16);
     
984.   con_disp(0xff,0xff,0x82,0x80,3,16);
     
985.   con_disp(0xe3,0xff,0x85,0x80,1,16);
     
986.   con_disp(0xff,0xff,0x86,0x80,2,16);
     
987. }
     
988. 
     
989. 
     
990. 
     
991. /*显示菜单图片  格式：图片反显(1)或正常显示(0)，显示图片的号码*/
     
992. void anti_nor_pic (uchar cpl_sign,uchar menu_num)
     
993. {
     
994.   uchar i,j,x,y;
     
995.   x=menu_num*3;    // 计算图片显示坐标
     
996.   if(x>6) x--;
     
997.   if(menu_num<3) y=16;  // 上下半屏显示
     
998.   else y=8;
     
999.   if(cpl_sign==1) display_cnasc(0x82,4,menu_cn[menu_num]);
     
1000.   for(j=0;j<24;j++)
      
1001.   {
      
1002.    for(i=0;i<2;i++)
      
1003.    {
      
1004.      wr_lcd(comm,0x34);
      
1005.      wr_lcd(comm,0x80+y);
      
1006.      wr_lcd(comm,0x80+x+i);  // 分两次显示 16bit
      
1007.      wr_lcd(comm,0x30);
      
1008.      if(cpl_sign==1)          // 图片反选
      
1009.      {
      
1010.        wr_lcd(dat,~menu_pic[menu_num][j*4+i*2]);
      
1011.        wr_lcd(dat,~menu_pic[menu_num][j*4+i*2+1]);
      
1012.      }
      
1013.      else                     // 正常显示
      
1014.      {
      
1015.        wr_lcd(dat,menu_pic[menu_num][j*4+i*2]);
      
1016.        wr_lcd(dat,menu_pic[menu_num][j*4+i*2+1]);
      
1017.      }
      
1018.    }
      
1019.    y++;
      
1020.    if(y==32&&menu_num<3) {x+=8;y=0;}  // 上下屏切换
      
1021.   }
      
1022.   wr_lcd(comm,0x36);
      
1023. }
      
1024. 
      
1025. 
      
1026. 
      
1027. 
      
1028. /*状态16*16图片  格式：反色（1）或正常0，X坐标，Y坐标，状态编码（16*16）*/
      
1029. void dis_run_state(uchar cpl,uchar x0,uchar y0,uchar state_num)
      
1030. {
      
1031.   uchar j;
      
1032.   for(j=0;j<16;j++)
      
1033.   {
      
1034.     wr_lcd(comm,0x34);  // 扩展功能
      
1035.     wr_lcd(comm,y0++);  // 写Y地址
      
1036.     wr_lcd(comm,x0);    // 写X地址
      
1037.     wr_lcd(comm,0x30);  // 普通功能
      
1038.     if(cpl==1)          // 写数据
      
1039.     {
      
1040.       wr_lcd(dat,~running[state_num][j*2]);
      
1041.       wr_lcd(dat,~running[state_num][j*2+1]);
      
1042.     }
      
1043.     else
      
1044.     {
      
1045.       wr_lcd(dat,running[state_num][j*2]);
      
1046.       wr_lcd(dat,running[state_num][j*2+1]);
      
1047.     }
      
1048.   }
      
1049.   wr_lcd(comm,0x36);
      
1050. }
      
1051. 
      
1052. 
      
1053. 
      
1054. /*显示菜单按钮  参数格式：反色(1)或正常(0)*/
      
1055. void dis_menu_key(uchar d)
      
1056. {
      
1057.   if(d==1)
      
1058.   {
      
1059.     for(d=0;d<8;d++)                                  // 显示菜单按钮
      
1060.       con_disp(~menu_key[d*2],~menu_key[d*2+1],0x9f,0x97+d,1,1);
      
1061.   }
      
1062.   else
      
1063.   {
      
1064.     for(d=0;d<8;d++)                                  // 显示菜单按钮
      
1065.       con_disp(menu_key[d*2],menu_key[d*2+1],0x9f,0x97+d,1,1);
      
1066.   }
      
1067. }
      
1068. 
      
1069. 
      
1070. 
      
1071. 
      
1072. /*显示模式3的界面*/
      
1073. void dis_mode3(void)
      
1074. {
      
1075.   uchar i,j,h,l,x_0=0x80,y_0=0x90;
      
1076.   h=now.hour>>4;       // 分离十位 个位
      
1077.   l=now.hour&0x0f;
      
1078.   for(j=0;j<2;j++)
      
1079.   {
      
1080.     for(i=0;i<32;i++)  // 十位个位一起读入
      
1081.     {
      
1082.       wr_lcd(comm,0x34);
      
1083.       wr_lcd(comm,y_0++);
      
1084.       wr_lcd(comm,x_0);
      
1085.       wr_lcd(comm,0x30);
      
1086.       wr_lcd(dat,mode_3num[h][i*3]);  // 连续写数据，X坐标自动加1
      
1087.       wr_lcd(dat,mode_3num[h][i*3+1]);
      
1088.       wr_lcd(dat,mode_3num[h][i*3+2]);
      
1089.       wr_lcd(dat,mode_3num[l][i*3]);
      
1090.       wr_lcd(dat,mode_3num[l][i*3+1]);
      
1091.       wr_lcd(dat,mode_3num[l][i*3+2]);
      
1092.       if(y_0==0xa0){x_0=x_0+8;y_0=0x80;}
      
1093.     }
      
1094.     x_0=0x84,y_0=0x90;
      
1095.     h=now.minute>>4;   // 分离十位 个位
      
1096.     l=now.minute&0x0f;
      
1097.   }
      
1098.   dis_run_state(0,0x83,0x90,4); // 显示点
      
1099.   dis_run_state(0,0x8b,0x80,4);                    
      
1100.   y_0=0x80;            // 显示状态标记
      
1101.   if(keb) {dis_run_state(0,0x87,y_0,2);y_0+=16;}
      
1102.   if(alm) {dis_run_state(0,0x87,y_0,1);y_0+=16;}
      
1103.   if(y_0<0xa0&&!als){dis_run_state(0,0x87,y_0,0);}
      
1104.   if(y_0==0xa0&&!als){dis_run_state(0,0x8f,0x80,0);}
      
1105.   dis_menu_key(0);
      
1106. }
      
1107. 
      
1108. 
      
1109. 
      
1110. 
      
1111. /*显示模式1和2的共用部分*/
      
1112. void mode1_2_union(void)
      
1113. {
      
1114.   uchar x=0x9b;
      
1115.   display_cnasc(0x98,2,"星期");
      
1116.   if(nba_tim) dis_run_state(0,x,0x90,6);
      
1117.   if(keb) {dis_run_state(0,x,0x90,2);x++;}    // 显示标记
      
1118.   if(alm) {dis_run_state(0,x,0x90,1);x++;}
      
1119.   if(!als){dis_run_state(0,x,0x90,0);}
      
1120.   dis_menu_key(0);                           // 显示菜单按钮
      
1121. }
      
1122. 
      
1123. 
      
1124. /*显示模式2的日期*/
      
1125. void dis_date_mode2(uchar d)
      
1126. {
      
1127.   uchar save[2];
      
1128.   display_cnasc(d+2,1,"年");
      
1129.   display_cnasc(d+4,1,"月");
      
1130.   display_cnasc(d+6,1,"日");
      
1131.   display_cnasc(0x9a,1,weeks[today.week]);  // 显示星期
      
1132.   save[0]=char_num[today.year>>4];          // 将显示的数值存到数组中
      
1133.   save[1]=char_num[today.year&0x0f];
      
1134.   display_cnasc(d+1,1,save);
      
1135.   save[0]=char_num[today.month>>4];
      
1136.   save[1]=char_num[today.month&0x0f];
      
1137.   display_cnasc(d+3,1,save);
      
1138.   save[0]=char_num[today.day>>4];
      
1139.   save[1]=char_num[today.day&0x0f];
      
1140.   display_cnasc(d+5,1,save);
      
1141. }
      
1142. 
      
1143. /*显示模式2的时间数字显示  16*32*/
      
1144. void num2_asc_dis(uchar num,uchar x_0)
      
1145. {
      
1146.   uchar i,y_0=0x90;
      
1147.   for(i=0;i<32;i++)  // 十位个位一起读入
      
1148.   {
      
1149.     wr_lcd(comm,0x36);
      
1150.     wr_lcd(comm,y_0++);
      
1151.     wr_lcd(comm,x_0);
      
1152.     wr_lcd(comm,0x30);
      
1153.     wr_lcd(dat,mode_2num[num][i*2]);
      
1154.     wr_lcd(dat,mode_2num[num][i*2+1]);
      
1155.     if(i==15){x_0+=8;y_0=0x80;}
      
1156.   }
      
1157.   wr_lcd(comm,0x36);
      
1158. }
      
1159. 
      
1160. /*显示模式2的时间*/
      
1161. void dis_time_mode2(void)
      
1162. {
      
1163.   uchar h,l;
      
1164.   if(now.hour!=save_time.hour||init_d2)
      
1165.   {
      
1166.     h=now.hour>>4;    // 分离十位 个位
      
1167.     l=now.hour&0x0f;
      
1168.     num2_asc_dis(h,0x80);
      
1169.     num2_asc_dis(l,0x80+1);
      
1170.   }
      
1171.   if(now.minute!=save_time.minute||init_d2)
      
1172.   {
      
1173.     h=now.minute>>4;    // 分离十位 个位
      
1174.     l=now.minute&0x0f;
      
1175.     num2_asc_dis(h,0x83);
      
1176.     num2_asc_dis(l,0x83+1);
      
1177.   }
      
1178.   if(now.second!=save_time.second||init_d2)
      
1179.   {
      
1180.     h=now.second>>4;    // 分离十位 个位
      
1181.     l=now.second&0x0f;
      
1182.     num2_asc_dis(h,0x86);
      
1183.     num2_asc_dis(l,0x86+1);
      
1184.   }
      
1185.   if(init_d2)
      
1186.   {
      
1187.     dis_run_state(0,0x82,0x90,5); // 显示点
      
1188.     dis_run_state(0,0x8a,0x80,5);
      
1189.     dis_run_state(0,0x85,0x90,5); // 显示点
      
1190.     dis_run_state(0,0x8d,0x80,5);
      
1191.   }
      
1192. }
      
1193. 
      
1194. 
      
1195. /*显示模式2的界面*/
      
1196. void dis_mode2(void)
      
1197. {
      
1198.   dis_date_mode2(0x81);       // 显示日期
      
1199.   display_cnasc(0x81,1,"20");
      
1200.   dis_time_mode2();           // 显示时间
      
1201.   mode1_2_union();
      
1202. }
      
1203. 
      
1204. 
      
1205. /*显示模式1的日期*/
      
1206. void dis_date_mode1(void)
      
1207. {
      
1208.   uchar save[2];
      
1209.   display_cnasc(0x80,3,"日期：");
      
1210.   display_cnasc(0x90,3,"时间：");
      
1211.   display_cnasc(0x88,3,"温度：");
      
1212.   display_cnasc(0x9a,1,weeks[today.week]);  // 显示星期
      
1213.   display_cnasc(0x83,1,"20");
      
1214.   save[0]=char_num[today.year>>4];            
      
1215.   save[1]=char_num[today.year&0x0f];
      
1216.   display_cnasc(0x84,1,save);
      
1217.   save[0]='/';
      
1218.   save[1]=char_num[today.month>>4];
      
1219.   display_cnasc(0x85,1,save);
      
1220.   save[0]=char_num[today.month&0x0f];
      
1221.   save[1]='/';
      
1222.   display_cnasc(0x86,1,save);
      
1223.   save[0]=char_num[today.day>>4];
      
1224.   save[1]=char_num[today.day&0x0f];
      
1225.   display_cnasc(0x87,1,save);
      
1226.   mode1_2_union();
      
1227. }
      
1228. 
      
1229. 
      
1230. /*显示模式1的时间*/
      
1231. void dis_time_mode1(void)
      
1232. {
      
1233.   uchar save[2];
      
1234.   save[0]=char_num[now.hour>>4];
      
1235.   save[1]=char_num[now.hour&0x0f];
      
1236.   display_cnasc(0x93,1,save);
      
1237.   save[0]=':';
      
1238.   save[1]=char_num[now.minute>>4];
      
1239.   display_cnasc(0x94,1,save);
      
1240.   save[0]=char_num[now.minute&0x0f];
      
1241.   save[1]=':';
      
1242.   display_cnasc(0x95,1,save);
      
1243.   save[0]=char_num[now.second>>4];
      
1244.   save[1]=char_num[now.second&0x0f];
      
1245.   display_cnasc(0x96,1,save);
      
1246. }
      
1247. 
      
1248. 
      
1249. /*显示模式1的温度*/
      
1250. void dis_temp_mode1(void)
      
1251. {
      
1252.   uchar save[2];
      
1253.   if(ds18b20)
      
1254.   {
      
1255.      if(temp.t_data[0]>99)
      
1256.      {
      
1257.         save[0]=char_num[temp.t_data[0]/100];
      
1258.         save[1]=char_num[(temp.t_data[0]/10)%10];
      
1259.         display_cnasc(0x8b,1,save);
      
1260.         save[0]=char_num[temp.t_data[0]%10];
      
1261.         save[1]='.';
      
1262.         display_cnasc(0x8c,1,save);
      
1263.         save[0]=char_num[temp.t_data[1]/10];
      
1264.         save[1]=' ';
      
1265.         display_cnasc(0x8d,1,save);
      
1266.         display_cnasc(0x8e,1,"℃");
      
1267.       }
      
1268.       else
      
1269.       {
      
1270.         if(temp_pn) display_cnasc(0x8a,1,":-");
      
1271.         else  display_cnasc(0x8a,1,"：");
      
1272.         save[0]=char_num[temp.t_data[0]/10];
      
1273.         save[1]=char_num[temp.t_data[0]%10];
      
1274.         display_cnasc(0x8b,1,save);
      
1275.         save[0]='.';
      
1276.         save[1]=char_num[temp.t_data[1]/10];
      
1277.         display_cnasc(0x8c,1,save);
      
1278.         display_cnasc(0x8d,1,"℃");
      
1279.       }
      
1280.     }
      
1281.   else display_cnasc(0x8b,3,"FF.F℃");
      
1282. }
      
1283. 
      
1284. 
      
1285. 
      
1286. /*显示模式1的界面*/
      
1287. void dis_mode1(void)
      
1288. {
      
1289.   dis_date_mode1();
      
1290.   dis_time_mode1();
      
1291.   dis_temp_mode1();
      
1292. }
      
1293. 
      
1294. 
      
1295. 
      
1296. /*篮球器时间显示*/
      
1297. void nba_dis_time(void)
      
1298. {
      
1299.   uchar d,dis[2];
      
1300.   for(d=2;d<4;d++)
      
1301.   {
      
1302.     dis[0]=char_num[resu[d]/10];
      
1303.     dis[1]=char_num[resu[d]%10];
      
1304.     display_cnasc(0x81+d*2,1,dis);
      
1305.   }
      
1306.   display_cnasc(0x86,1,": ");
      
1307.   if(resu[0]==1)
      
1308.   {
      
1309.     dis[0]='\x07';
      
1310.     dis[1]=char_num[resu[4]/10];
      
1311.     display_cnasc(0x93,1,dis);
      
1312.     dis[1]='\x07';
      
1313.     dis[0]=char_num[resu[4]%10];
      
1314.     display_cnasc(0x94,1,dis);
      
1315.   }
      
1316. }
      
1317. 
      
1318. 
      
1319. /*=====================================================================================
      
1320. 函数名称：键盘扫描
      
1321. 功能描述：读取键盘操作数据及部分状态的实现
      
1322. 全局变量：dis_sig  t0_isr  temprun  b20time  alm_run als_temp   buzstop  als
      
1323.            lock_op  nba_tim
      
1324. 参数说明：无
      
1325. 返回说明：键盘锁与密码锁时间到达后返回 255
      
1326. 设 计 人：JZHG   
      
1327. 版    本：1.0
      
1328. 说    明：
      
1329. ======================================================================================*/
      
1330. 
      
1331. /*扫描键盘*/
      
1332. uchar  keypad_scan()
      
1333. {
      
1334.   uchar key,dis[2];
      
1335.   keyboard=0xf0;
      
1336.   while (keyboard==0xf0)     // 等待按键按下
      
1337.   {  
      
1338. 
      
1339.   /*--------------------- 背光灯关闭延时 -----------------------*/
      
1340.    
      
1341.     delay(1000);                     
      
1342.     if((++dis[0])==0&&bl_delay!=0) bl_delay--;  // 当有按键按下bl_delay重新赋值     
      
1343.     if(bl_delay==0&&!bl0) lcd_bl=close;         // 背光时间到且不是常开模式时关闭背光
      
1344. 
      
1345.       
      
1346.   /*----------------------- 键盘锁延时 -------------------------*/  
      
1347. 
      
1348.     if(keb&&dis_sig&&bl_delay==0&&resu[11]<2) resu[11]++; // 当有按键按下j清零
      
1349.     if(bl_delay==0) bl_delay=15;
      
1350. 
      
1351. 
      
1352.   /*--------------------- 密码锁30秒锁延时 ---------------------*/      
      
1353. 
      
1354.     if(lock_op)                     
      
1355.     {
      
1356.       if((++i)==0) save1++;     
      
1357.       if(save1==15) return(255);
      
1358.     }
      
1359.    
      
1360. 
      
1361.   /*---------------------- 时钟界面时间显示 ---------------------*/
      
1362.    
      
1363.     if(dis_sig&&t0_isr||nba_tim&&oth_run)     // 正常时钟界面与篮球器返回时钟界面显示
      
1364.     {   
      
1365.       rds1302_date();       // 读出日期
      
1366.       rds1302_time();       // 读出时间
      
1367.       if(di0)               // 模式2
      
1368.       {
      
1369.         dis_time_mode2();
      
1370.         if(now.hour==0&&now.minute==0&&now.second==0)   dis_date_mode2(0x81);
      
1371.       }
      
1372.       else if(di1)          // 模式3
      
1373.       {
      
1374.         if(now.hour!=save_time.hour||now.minute!=save_time.minute)   // 时,分变化后显示
      
1375.           dis_mode3();     
      
1376.       }
      
1377.       else
      
1378.       {
      
1379.         dis_time_mode1();   // 模式1
      
1380.         if(now.hour==0&&now.minute==0&&now.second==0) dis_date_mode1();
      
1381.       }
      
1382.       save_time=now;        // 重新记录作下次比较
      
1383.       t0_isr=0;
      
1384.     }
      
1385.   
      
1386.   
      
1387.   /*-------------------- 温度计提示按键操作 ----------------------*/
      
1388.    
      
1389.     if(temprun)
      
1390.     {
      
1391.       if(!oth_run)
      
1392.       {
      
1393.         display_cnasc(0x96,2," key");    // 温度计时提示按键操作
      
1394.         for(dis[1]=0;dis[1]<250;dis[1]++)
      
1395.         {
      
1396.           delay(1000);
      
1397.           if(keyboard!=0xf0)
      
1398.           {
      
1399.             keyboard=0x7f;
      
1400.             if(keyboard==0x7d) return 0x7d;
      
1401.             else  keyboard=0xf0;
      
1402.           }
      
1403.         }
      
1404.         oth_run=1;
      
1405.         display_cnasc(0x96,2,"    ");
      
1406.       }
      
1407.     }
      
1408.   
      
1409.   
      
1410.    /*------------------------ 蜂鸣器警报 --------------------------*/
      
1411. 
      
1412.    
      
1413.     if(((alm_run&&alm)||thl_als)&&!buzstop) // 温度，闹铃蜂鸣器警报
      
1414.     {                                       // 有按键按下时停止
      
1415.       if(now.second==0) lcd_bl=close;
      
1416.       delay(15000);                         // 读出温度时间比较
      
1417.       if(keyboard!=0xf0) break;
      
1418.       delay(15000);
      
1419.       if(keyboard!=0xf0) break;
      
1420.       delay(15000);
      
1421.       if(keyboard!=0xf0) break;
      
1422.       delay(15000);
      
1423.       if(alm_run)  lcd_bl=!lcd_bl;          // 只在闹铃功能闪
      
1424.       if(!als)buzzer=!buzzer;               // 警报开启后蜂鸣器开启            
      
1425.     }
      
1426. 
      
1427. 
      
1428.   /*----------------------- 温度刷新显示 -------------------------*/
      
1429. 
      
1430.    
      
1431.     if((temprun&&oth_run)||(b20time&&!di0&&!di1&&dis_sig))    // 温度计功能于模式1界面
      
1432.     {  
      
1433.      
      
1434.         ds18b20_func();                           // 温度检测功能
      
1435.         oth_run=0;                                // 作交替标记用
      
1436.         if(temprun) return 20;                    // 温度计开启后返回
      
1437.         if(b20time){ dis_temp_mode1();b20time=0;} // 时钟界面5分钟更新一次，T0计时
      
1438.     }
      
1439. 
      
1440.   
      
1441.    
      
1442.    /*------------------------ 篮球器显示时间 ------------------------*/
      
1443.    
      
1444.     if(nba_tim&!oth_run)        // 当篮球器模式下 oth_run==0为篮球器计时状态
      
1445.     {
      
1446.       if(EA) display_cnasc(0x8b,2," R\x10 ");  // 显示运行状态
      
1447.       else  display_cnasc(0x8b,2," S! ");
      
1448.       if(t0_isr)
      
1449.       {                                        // 更新时间
      
1450.         nba_dis_time();
      
1451.         if(resu[2]==0&&resu[3]==0)             // 判断比赛情况
      
1452.         {
      
1453.           resu[6]++;
      
1454.           if(resu[6]<resu[1])  display_cnasc(0x85,3,"休息  ");
      
1455.           else  display_cnasc(0x85,3,"完结  ");
      
1456.         }
      
1457.         if(resu[4]==0||(resu[2]==0&&resu[3]==0))  // 时间到达警报
      
1458.         {
      
1459.            buzzer=open;
      
1460.            delay_pw();
      
1461.            if(resu[2]==0&&resu[3]==0)  // 24秒 总时间警报
      
1462.            {
      
1463.              delay_pw();
      
1464.            }
      
1465.            buzzer=close;
      
1466.            if(resu[4]==0) resu[4]=24;  // 重新赋值
      
1467.         }
      
1468.         t0_isr=0;                      // 清零等下次中断产生
      
1469.       }
      
1470.     }
      
1471.   }
      
1472. 
      
1473.               
      
1474.                     /*===== 以上等待按键 =====*/
      
1475. 
      
1476. 
      
1477. 
      
1478.   /*------------------------- 按键按下后 --------------------------*/
      
1479. 
      
1480.   
      
1481.   delay(8000);               // 消抖振
      
1482.   if(!lock_op)bl_delay=15;   // 背光时间赋值
      
1483.   if(bl1) lcd_bl=close;      // 不在背光灯关闭时亮起
      
1484.   else lcd_bl=open;
      
1485.   if(alm_run|thl_als) {buzstop=1;buzzer=close;}
      
1486.   if(keb&&dis_sig)
      
1487.   {
      
1488.     if(resu[11]==2) return 255;  // 要求输入密码   
      
1489.     else resu[11]=0;             // 时间不到时重新计时
      
1490.   }
      
1491.   do
      
1492.   {     
      
1493.     for(dis[0]=0;dis[0]<=3;dis[0]++)
      
1494.     {
      
1495.       keyboard=ksp[dis[0]];
      
1496.       if(keyboard!=ksp[dis[0]])
      
1497.       {
      
1498.         key=keyboard;
      
1499.         if(key!=ksp[dis[0]]) return(key);
      
1500.       }
      
1501.     }
      
1502.   }while(1);
      
1503. }
      
1504. 
      
1505. 
      
1506. /*读键盘数据*/
      
1507. uchar  gotkey()
      
1508. {
      
1509.   uchar  save,n;
      
1510.   keyboard=0xf0;
      
1511.   while(keyboard!=0xf0);    // 等待键盘松开
      
1512.   delay(5000);              // 消抖阵
      
1513.   if(adju_si)               // 连写输入
      
1514.   {
      
1515.     adju_si=0;
      
1516.     for(n=0;n<60;n++)
      
1517.     {
      
1518.       delay(2000);
      
1519.       if(keyboard!=0xf0)
      
1520.       {
      
1521.         adju_si=1;          // 在更改时,在此时间内可连成多位数
      
1522.         break;
      
1523.       }
      
1524.     }
      
1525.   }         
      
1526.   save=keypad_scan();       // 扫描键盘
      
1527.   if(save==255) return 255; // 要求输入键盘锁密码或延时时间到达
      
1528.   for (n=0;n<16;n++)
      
1529.   {  
      
1530.     if(save==key_code[n])
      
1531.        return(n);
      
1532.   }
      
1533.   return(20);
      
1534. }
      
1535. 
      
1536. 
      
1537. 
      
1538. /*=====================================================================================
      
1539. 函数名称：导航
      
1540. 功能描述：主菜单 工具导航  保存提示
      
1541. 全局变量：无
      
1542. 参数说明：
      
1543. 返回说明：无
      
1544. 设 计 人：JZHG
      
1545. 版    本：1.0
      
1546. 说    明：
      
1547. ======================================================================================*/
      
1548. 
      
1549. 
      
1550. /*按键按下显示 参数格式：k 按钮的显示地址*/
      
1551. void key_dis(uchar k)
      
1552. {
      
1553.   display_cnasc(k,1,"\x04 ");
      
1554.   delay(10000);
      
1555.   if(k==0x92||k==0x96) display_cnasc(k,1,"\x1e ");
      
1556.   else display_cnasc(k,1,"\x1f ");
      
1557. }
      
1558. 
      
1559. 
      
1560. 
      
1561. /*确定按键按下显示*/
      
1562. void enter_dis(void)
      
1563. {
      
1564.   display_cnasc(0x8f,1," \x09");
      
1565.   delay(15000);
      
1566. }
      
1567. 
      
1568. 
      
1569. 
      
1570. /*主菜单导航*/
      
1571. uchar dis_menu(void)
      
1572. {
      
1573.   uchar d,save,key;
      
1574.   if(meu)
      
1575.   {  
      
1576.     display_cnasc(0x81,2,"菜单");
      
1577.     dis_title();
      
1578.     display_cnasc(0x88,8,selected[0]);
      
1579.     con_disp(0xff,0xff,0x8a,0x80,5,16);
      
1580.   }
      
1581.   else    // 显示图片菜单
      
1582.   {
      
1583.     dis_title_pic();
      
1584.     for(d=0;d<6;d++)  
      
1585.       anti_nor_pic(0,d);
      
1586.     anti_nor_pic(1,0);
      
1587.   }      
      
1588.   save=d=0;
      
1589.   do
      
1590.   {                                                                           
      
1591.     if(meu)   // 操作指示更新
      
1592.     {     
      
1593.       display_cnasc(0x93,3,menu_cn_2[index_m[save].right_num]);
      
1594.       display_cnasc(0x8b,3,menu_cn_2[save]);
      
1595.       display_cnasc(0x9b,3,menu_cn_2[index_m[save].left_num]);
      
1596.     }
      
1597.     else
      
1598.     {
      
1599.       anti_nor_pic(0,d);     
      
1600.       anti_nor_pic(1,save);
      
1601.     }
      
1602.     d=save;               // 保存上一索引
      
1603.     while(1)
      
1604.     {
      
1605.       key=gotkey();
      
1606.       if(key==11||(key==3&&meu))
      
1607.       {
      
1608.         if(meu) enter_dis();
      
1609.         break;
      
1610.       }
      
1611.       else if(meu)
      
1612.       {                                 
      
1613.         if(key==2)
      
1614.         {
      
1615.           save=index_m[d].left_num;
      
1616.           key_dis(0x9a);
      
1617.           break;
      
1618.         }
      
1619.         if(key==5)
      
1620.         {
      
1621.           save=index_m[d].right_num;
      
1622.           key_dis(0x92);
      
1623.           break;
      
1624.         }
      
1625.         if((key==1&&meu))
      
1626.         {
      
1627.           d=5;
      
1628.           break;
      
1629.         }
      
1630.       }
      
1631.       else
      
1632.       {
      
1633.         if(key==3){save=index_m[d].left_num; break;} // 根据导航键寻找索引
      
1634.         if(key==1){save=index_m[d].right_num; break;}
      
1635.         if(key==2||key==5){save=index_m[d].shaft_num; break;}  
      
1636.       }
      
1637.     }
      
1638.     if(key==11||((key==1|key==3)&&meu)) break;
      
1639.   }while(1);
      
1640.   return d;
      
1641. }
      
1642. 
      
1643. 
      
1644. 
      
1645. /*工具导航*/
      
1646. uchar tool_func(void)
      
1647. {
      
1648.   uchar save,d,key;
      
1649.   display_cnasc(0x81,2,"工具");
      
1650.   dis_title();
      
1651.   display_cnasc(0x88,8,selected[0]);
      
1652.   con_disp(0xff,0xff,0x8a,0x80,5,16);
      
1653.   d=0;
      
1654.   save=0;
      
1655.   do
      
1656.   {   
      
1657.     display_cnasc(0x93,3,tool_menu[index_t[save].lnum]);
      
1658.     display_cnasc(0x8b,3,tool_menu[save]);
      
1659.     display_cnasc(0x9b,3,tool_menu[index_t[save].rnum]);
      
1660.     d=save;
      
1661.     while(1)
      
1662.     {
      
1663.       key=gotkey();
      
1664.       if(key==1){ d=4;break;}               // 根据按键寻找索引
      
1665.       if(key==11||key==3){enter_dis();break;}
      
1666.       if(key==2){save=index_t[d].rnum; key_dis(0x9a);break;}
      
1667.       if(key==5){save=index_t[d].lnum; key_dis(0x92);break;}
      
1668.     }
      
1669.     if(key==11||key==3||key==1) break;
      
1670.   }while(1);
      
1671.   return d;
      
1672. }
      
1673. 
      
1674. 
      
1675. 
      
1676. 
      
1677. /*更改后提示保存*/
      
1678. void save_y_or_n(void)
      
1679. {
      
1680.   uchar key;
      
1681.   clear_dis();
      
1682.   oth_run=0;      
      
1683.   display_cnasc(0x92,5,"是否保存? ");
      
1684.   display_cnasc(0x89,6,"Y(OK)\\N(./S)");
      
1685.   while(1)
      
1686.   {
      
1687.     key=gotkey();
      
1688.     if(key==11)
      
1689.     {
      
1690.       display_cnasc(0x9a,5,"保存成功！ ");
      
1691.       delay(50000);
      
1692.       oth_run=1;     // 要求保存时oth_run标记为1
      
1693.       return;
      
1694.     }
      
1695.     if(key==10) return;
      
1696.   }
      
1697. }
      
1698. 
      
1699. 
      
1700. /*=====================================================================================
      
1701. 函数名称：调整功能
      
1702. 功能描述：时间日期调整
      
1703. 全局变量：today  now
      
1704. 参数说明：见函数
      
1705. 返回说明：无
      
1706. 设 计 人：JZHG
      
1707. 版    本：1.0
      
1708. 说    明：
      
1709. ======================================================================================*/
      
1710. 
      
1711. 
      
1712. /*调整功能显示时间*/
      
1713. void asjust_time()
      
1714. {
      
1715.   uchar save[2];
      
1716.   display_cnasc(0x8a,1,"时");
      
1717.   display_cnasc(0x8c,1,"分");
      
1718.   display_cnasc(0x8e,1,"秒");
      
1719.   save[0]=char_num[now.hour>>4];
      
1720.   save[1]=char_num[now.hour&0x0f];
      
1721.   display_cnasc(0x89,1,save);
      
1722.   save[0]=char_num[now.minute>>4];
      
1723.   save[1]=char_num[now.minute&0x0f];
      
1724.   display_cnasc(0x8b,1,save);
      
1725.   save[0]=char_num[now.second>>4];
      
1726.   save[1]=char_num[now.second&0x0f];
      
1727.   display_cnasc(0x8d,1,save);
      
1728. }
      
1729. 
      
1730. 
      
1731. /*调整功能月天数比较*/
      
1732. uchar monthday(uchar year,uchar month)
      
1733. {
      
1734.   if(month==2&&year%4==0)
      
1735.     return(29);
      
1736.   else
      
1737.   { year=month&0x0f;
      
1738.     month>>=4;
      
1739.     month=month*10+year;   
      
1740.     return(dayofmonth[month-1]);}
      
1741. }
      
1742. 
      
1743. 
      
1744. 
      
1745. /*星期推算*/
      
1746. void weeks_day()
      
1747. {
      
1748.   uchar d,buffer,day=4;
      
1749.   if(today.month>1)
      
1750.   {
      
1751.     buffer=(today.month>>4);   // 将BCD码转为十进制
      
1752.     buffer=buffer*10;
      
1753.     buffer+=(today.month&0x0f);
      
1754.     for(d=0;d<buffer-1;d++)
      
1755.     {
      
1756.       today.week=(dayofmonth[d]>>4);
      
1757.       today.week=today.week*10;
      
1758.       today.week+=(dayofmonth[d]&0x0f);
      
1759.       day+=(today.week%7);
      
1760.     }
      
1761.   }
      
1762.   buffer=(today.year>>4);
      
1763.   buffer*=10;
      
1764.   buffer+=(today.year&0x0f);
      
1765.   if(today.year!=0)
      
1766.   {
      
1767.     day+=((buffer-1)/4)+buffer+1;
      
1768.   }
      
1769.   if(buffer%4==0&&today.month>2) day++;
      
1770.   buffer=today.day>>4;
      
1771.   buffer*=10;
      
1772.   buffer+=(today.day&0x0f);
      
1773.   today.week=(day+buffer)%7;
      
1774. }
      
1775. 
      
1776. 
      
1777. 
      
1778. /*调整功能*/
      
1779. void adjust_func(void)
      
1780. {
      
1781.   uchar d,save,b=0;
      
1782.   dis_title_e();
      
1783.   display_cnasc(0x82,3,menu_cn_2[0]);
      
1784.   rds1302_date();
      
1785.   rds1302_time();
      
1786.   dis_date_mode2(0x90);
      
1787.   display_cnasc(0x9a,1,"  ");
      
1788.   asjust_time();
      
1789.   display_cnasc(0x9f,1,"→");
      
1790.   display_cnasc(0x90,1,"『");
      
1791.   display_cnasc(0x8f,1,"』");
      
1792.   d=0;save=0;
      
1793.   adju_si=0;
      
1794.   do
      
1795.   {
      
1796.     con_disp(0x00,0x00,index_a[d].lnum,index_a[d].rnum,1,13);
      
1797.     con_disp(0xff,0xff,index_a[save].lnum,index_a[save].rnum,1,13);
      
1798.     d=save;
      
1799.     while(1)
      
1800.     {
      
1801.       save=gotkey();
      
1802.       if(save>=0&&save<10)
      
1803.       {
      
1804.         switch(d)
      
1805.         {
      
1806.           case 0: if(adju_si) // adju_si==1时两次输入连成一个数
      
1807.                   {
      
1808.                     today.year<<=4;
      
1809.                     today.year+=save;adju_si=0;
      
1810.                   }
      
1811.                   else
      
1812.                   {
      
1813.                     today.year=save;adju_si=1;
      
1814.                   }
      
1815.                   break;
      
1816.           case 1: if(adju_si)
      
1817.                   {
      
1818.                     today.month<<=4;today.month+=save;
      
1819.                     if(today.month>0x12) today.month=save;
      
1820.                     else adju_si=0;
      
1821.                   }
      
1822.                   else  
      
1823.                   {
      
1824.                     today.month=save;adju_si=1;
      
1825.                   }
      
1826.                   break;
      
1827.           case 2: if(adju_si)
      
1828.                   {
      
1829.                     today.day<<=4;today.day+=save;  // 月天数比较
      
1830.                     if(today.year%4==0&&today.month==2&&today.day==29) ;
      
1831.                     else if(today.day>monthday(today.year,today.month))
      
1832.                       today.day=save;
      
1833.                     else adju_si=0;
      
1834.                   }
      
1835.                   else  {today.day=save;adju_si=1;}
      
1836.                   break;
      
1837.           case 3: if(adju_si)
      
1838.                   {
      
1839.                     now.hour<<=4;now.hour+=save;
      
1840.                     if(now.hour>0x23) now.hour=save;
      
1841.                     else adju_si=0;
      
1842.                   }
      
1843.                   else  {now.hour=save;adju_si=1;}
      
1844.                   break;
      
1845.           case 4: if(adju_si)
      
1846.                   {
      
1847.                     now.minute<<=4;now.minute+=save;
      
1848.                     if(now.minute>0x59) now.minute=save;
      
1849.                     else adju_si=0;
      
1850.                   }
      
1851.                   else  {now.minute=save;adju_si=1;}
      
1852.                   break;
      
1853.           case 5: if(adju_si)
      
1854.                   {
      
1855.                     now.second<<=4;now.second+=save;
      
1856.                     if(now.second>0x59) now.second=save;
      
1857.                     else adju_si=0;
      
1858.                   }
      
1859.                   else  {now.second=save;adju_si=1;}
      
1860.                   break;
      
1861.         }
      
1862.         if(today.day>monthday(today.year,today.month)) today.day=1; // 更改月份时判断天数
      
1863.         if(today.month==0) today.month=1;
      
1864.         if(today.day==0) today.day=1;
      
1865.         if(d<3) dis_date_mode2(0x90);   // 更新显示
      
1866.         else asjust_time();
      
1867.         display_cnasc(0x9a,1,"  ");     // 消去星期显示
      
1868.       }
      
1869.       if(save==11){save=d+1;adju_si=0;break;}
      
1870.       if(save==10&&d!=0){save=d-1;adju_si=0;break;}
      
1871.     }
      
1872.     if(save==7&d==6) break;
      
1873.   }while(1);
      
1874.   weeks_day();    // 计算星期
      
1875.   save_y_or_n();  // 需要保存时oth_run设为1
      
1876.   if(oth_run) wds1302_time_date();
      
1877. }
      
1878. 
      
1879. 
      
1880. 
      
1881. 
      
1882. /*=====================================================================================
      
1883. 函数名称：计算器功能
      
1884. 功能描述：10位带符号数的加减乘除运算
      
1885. 全局变量：opera  resu  i  j
      
1886. 参数说明：见函数
      
1887. 返回说明：无
      
1888. 设 计 人：JZHG
      
1889. 版    本：1.0
      
1890. 说    明：
      
1891. ======================================================================================*/
      
1892. 
      
1893. 
      
1894. 
      
1895. /*清寄存器  参数格式：m=2时结果寄存器，当m=1时操作数1，当m=0时操作数0(1),
      
1896.                         n=1时,只清寄存器不清显示, 0两清*/
      
1897. void removal_data(uchar m,uchar n)
      
1898. {
      
1899.   uchar l;      // 当n=1时,只清寄存器不清显示, 0两清
      
1900.   if(m==2)      // 当m=2时结果寄存器
      
1901.   {             // 当m=1时操作数1
      
1902.     if(n==0)    // 当m=0时操作数0 ,1
      
1903.       for(l=0;l<6;l++)
      
1904.         display_cnasc(0x98+l,1,"  ");
      
1905.     for(l=0;l<12;l++)
      
1906.       resu[l]=0;
      
1907.   }
      
1908.   while(m<2)
      
1909.   {
      
1910.     if(n==0)
      
1911.     {
      
1912.       if(m==0)
      
1913.       {  
      
1914.         for(l=0;l<6;l++)
      
1915.           display_cnasc(0x90+l,1,"  ");
      
1916.           display_cnasc(0x95,1," 0");
      
1917.       }
      
1918.       else
      
1919.          for(l=0;l<6;l++)
      
1920.             display_cnasc(0x88+l,1,"  ");
      
1921.     }
      
1922.     for(l=0;l<12;l++)
      
1923.       opera[m][l]=0;
      
1924.     m++;
      
1925.   }
      
1926. }
      
1927. 
      
1928. 
      
1929. 
      
1930. 
      
1931. /*显示数值  参数格式：显示首地址*/
      
1932. void dis_cdata(uchar ass)
      
1933. {
      
1934.   uchar p,d,save[2];
      
1935.   if(i==0&&opera[0][0]==1)      // 显示符号
      
1936.   {
      
1937.     if(cal_run)  display_cnasc(0x98,1,"=-");
      
1938.     else  display_cnasc(0x90,1," -");
      
1939.   }
      
1940.   d=opera[ i][11];               // 计算位数
      
1941.   if(opera[ i][10]!=0&&opera[ i][10]!=opera[ i][11]+1) d++;
      
1942.   save[0]=d/2;ass=ass-save[0]+5;    // 计算显示的开始位置
      
1943.   p=1;
      
1944.   cal_del=0;                    // 显示点标记 （0为没有显示）
      
1945.   if(d%2==1)                    // 对位数位奇数先处理首位
      
1946.   {
      
1947.     save[0]=' ';
      
1948.     save[1]=char_num[opera[ i][1]];
      
1949.     display_cnasc(ass,1,save);
      
1950.     p++;
      
1951.   }
      
1952.   ass++;                        // 显示地址加一
      
1953.   while(p<=opera[ i][11])
      
1954.   {                                             
      
1955.     if(opera[ i][10]==p&&(!cal_del)) {   // 显示点且作标记
      
1956.       save[0]='.';cal_del=1;}
      
1957.     else {
      
1958.       save[0]=char_num[opera[ i][p]]; p++;}
      
1959.     if(opera[ i][10]==p&&(!cal_del)) {
      
1960.       save[1]='.';cal_del=1;}
      
1961.     else{
      
1962.       save[1]=char_num[opera[ i][p]];p++;}
      
1963.     display_cnasc(ass,1,save);
      
1964.     ass++;
      
1965.   }
      
1966. }   
      
1967. 
      
1968. 
      
1969. /*从键盘中写入数据*/   
      
1970. char input_data()
      
1971. {
      
1972.   uchar save=20,c;
      
1973.   for(;i<2;i++)
      
1974.   {
      
1975.     while(1)
      
1976.     {
      
1977. pp:   save=gotkey();    // 读键盘
      
1978.       if(save==20) continue;
      
1979.       if(save==11)      // 按键为确定时,选择计算或删除
      
1980.       {
      
1981.         c=save=0;
      
1982.         while(1)        // 反色选择
      
1983.         {
      
1984.           con_disp (0x00,0x00,index_cal[save].lnum,index_cal[save].rnum,2,16);
      
1985.           con_disp (0xff,0xff,index_cal[c].lnum,index_cal[c].rnum,2,16);   
      
1986.           save=gotkey();
      
1987.           if(save==10)
      
1988.           {
      
1989.             save=c;
      
1990.             if(++c==3) c=0;
      
1991.           }
      
1992.           else if(save==11)
      
1993.           {
      
1994.             if(c==0) save=11;
      
1995.             else if(c==1) save=16;
      
1996.             else  return 0;
      
1997.             break;
      
1998.           }
      
1999.           else break;
      
2000.         }
      
2001.         con_disp (0x00,0x00,index_cal[c].lnum,index_cal[c].rnum,2,16);      
      
2002.       }
      
2003.       if(save>=0&&save<=9&&j<10)
      
2004.       {
      
2005.         if(i==1&&opera[1][0]==15&&j>8) goto pp;
      
2006.         if(j==2&&opera[ i][1]==0&&opera[ i][10]==0)
      
2007.           opera[ i][1]=save;     // 防止小数位不在时首位为零
      
2008.         else{
      
2009.           opera[ i][j]=save;opera[ i][11]=j;j++;}
      
2010.         if(i==0)                // 显示
      
2011.           dis_cdata(0x90);
      
2012.         else
      
2013.           dis_cdata(0x88);
      
2014.       }
      
2015.       else if(save==10&&j<10)   
      
2016.       {
      
2017.         if(opera[ i][10]==0)     // 小数点空时保存
      
2018.         {
      
2019.           if(opera[ i][11]==0) {opera[ i][10]=2;j++;}
      
2020.           else  opera[ i][10]=j;
      
2021.         }
      
2022.       }
      
2023.       else if(save==16)
      
2024.       {                           // 删除数据
      
2025.         removal_data(i,0);j=1;
      
2026.         if(i!=0){i--;j=10;}
      
2027.       }
      
2028.       else if(i==1&&opera[1][11]!=0&&save>11&&save<16)
      
2029.       { save1=save;break; }         // 连续计算时保存运算符
      
2030.       else if(save==11&&opera[1][11]==0) continue;// 操作数1为0时不理会
      
2031.       else if(save==11&&opera[1][11]!=0)  break;
      
2032.       else if((i==0||i==1&&j==1)&&save>11&&save<16){i=0; break;}   
      
2033.        // 当操作数0由运算符结束输入,再按符号键更改
      
2034.       else continue;
      
2035.     }
      
2036.     if(opera[ i][10]>opera[ i][11]||opera[ i][10]==0)
      
2037.       opera[ i][10]=opera[ i][11]+1;  // 整数时小数位保存到最后
      
2038.     while(opera[ i][11]>=opera[ i][10]&&opera[ i][opera[ i][11]]==0)
      
2039.       opera[ i][11]--;               // 去除小数点后多余的0
      
2040.     if(i==0)
      
2041.     {
      
2042.       opera[1][0]=save;         // 保存运算符并显示
      
2043.       display_cnasc(0x88,1,tool_cal[save-12]);
      
2044.     }
      
2045.     if(opera[0][11]==0) display_cnasc(0x95,1," 0");
      
2046.     j=1;
      
2047.     while(j<=opera[ i][11]&&opera[ i][j]==0) j++;//判断是否操作数是否全为0
      
2048.     j--;
      
2049.     if(j==opera[ i][11]) opera[ i][11]=0;
      
2050.     j=1;
      
2051.   }
      
2052.   return 1;
      
2053. }
      
2054. 
      
2055. 
      
2056. /****************************************************************************************
      
2057. 功能:  乘法运算
      
2058. 描述:  结果由右到左保存
      
2059. 参数:  i , j , opera[ i][j],p,q,r,k,save1
      
2060. 返回值：1(成功),0(结果位0),-1(溢出)
      
2061. /****************************************************************************************/
      
2062. 
      
2063. char multiplication()
      
2064. {
      
2065.   uchar p,q,r,k,save1=0; // p指向操作数0 ,q指向操作数1,r指向结果
      
2066.   if(opera[0][11]==0||opera[1][11]==0) return 0;
      
2067.   resu[10]=opera[0][11]+opera[1][11]-opera[0][10]-opera[1][10]+2; // RESU记录小数点后的位数
      
2068.   q=opera[1][11];                   // 记录操1的位数
      
2069.   r=9;
      
2070.   opera[1][11]=1;
      
2071.   k=1;
      
2072.   while(opera[1][k]==0) {opera[1][11]=opera[1][11]+1;k++;}  // 去除前端的0
      
2073.   k=1;
      
2074.   while(opera[0][k]==0) k++;            // 去除前端的0
      
2075.   resu[11]=9;
      
2076.   for(resu[0]=9;q>=opera[1][11];q--,resu[0]--)
      
2077.   {
      
2078.     if(opera[1][q]==0) continue;        // 操1此位数为0时直接比较
      
2079.     for(p=opera[0][11],r=resu[0];p>=k;p--)
      
2080.     {
      
2081.       save1=opera[0][p]*opera[1][q];        // 将相乘后的数保存
      
2082.       resu[r]+=(save1%10);//将缓存中的数取余后加到结果中R指向的位
      
2083.       save1/=10;
      
2084.       save1=save1+(resu[r]/10);         // 保存进位的数
      
2085.       resu[r]%=10;                  // 重新写入
      
2086.       if(r==1)  //结果有溢出时移位
      
2087.       {
      
2088.         if(save1==0&&p==k) break;   // 计算到最后位且没进位跳出
      
2089.         else if(resu[10]>0)     // 要求有小数存在
      
2090.         {
      
2091.           for(r=9;r>1;r--) resu[r]=resu[r-1];
      
2092.           r=1;
      
2093.           resu[r]=save1;
      
2094.           resu[11]=1;
      
2095.           resu[10]--;
      
2096.           resu[0]++;
      
2097.         }   
      
2098.         else   return -1;           // 否则溢出
      
2099.       }
      
2100.       if(r>1&&(r-1)<resu[11])           // 保存结果位的最高位
      
2101.       {
      
2102.         if(save1!=0) resu[11]=r-1;
      
2103.         else resu[11]=r;
      
2104.       }
      
2105.       if(r>1){ r--;resu[r]+=save1;}// 当R为1时只需要移位记录结果
      
2106.     }
      
2107.   }
      
2108.   while(resu[resu[11]]==0) resu[11]++;  // 去除前端的0
      
2109.   resu[0]=opera[0][0];              // 保存符号位
      
2110.   removal_data(0,1);                    // 清数据不清显示
      
2111.   if(resu[10]>8)   //如果小数点后的数有9 位或以上时，需后移到使小数点放到2的位置  
      
2112.   {
      
2113.     save1=resu[10]-10+resu[11];         // 记录后移位数
      
2114.     if(save1>7)  return 0;   //当后移的数大于有效数字的位数时结果为0
      
2115.     else    // 否则按需移位
      
2116.     {
      
2117.       for(p=save1+2,r=resu[11];p<10;p++,r++) opera[0][p]=resu[r];
      
2118.       opera[0][10]=2;opera[0][11]=9;opera[0][0]=resu[0];
      
2119.     }       // 因有效数小于小数点后的数,所以首位为0  
      
2120.   }
      
2121.   else      //如果小数点后的数在8位以内时分两种情况
      
2122.   {
      
2123.     opera[0][0]=resu[0];  
      
2124.     save1=10-resu[11];  // 记录有效位数
      
2125.     if(resu[10]>=save1)     // 小数的在有效数字的左边
      
2126.     {   
      
2127.       for(p=resu[10]+1,r=9;r>=resu[11];p--,r--)
      
2128.         opera[0][p]=resu[r];    // 从小数点的最后一位开始
      
2129.       opera[0][10]=2;opera[0][11]=resu[10]+1;
      
2130.     }
      
2131.     else                // 小数点在有效数字内
      
2132.     {  
      
2133.       for(p=1,r=resu[11];r<10;p++,r++) opera[0][p]=resu[r];
      
2134.         opera[0][11]=10-resu[11];
      
2135.       if(resu[10]==0) opera[0][10]=opera[0][11]+1;
      
2136.       else opera[0][10]=opera[0][11]-resu[10]+1;
      
2137.     }
      
2138.   }
      
2139.   while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0)
      
2140.     opera[0][11]--;     // 去除小数点后多余的0
      
2141.   return 1;
      
2142. }
      
2143. 
      
2144. 
      
2145. /****************************************************************************************
      
2146. 功能:  除法运算
      
2147. 描述:  结果由左到右保存
      
2148. 参数:  i , j , opera[ i][j]
      
2149. p,q,r, remainde, divisor, decimal
      
2150. 返回值：1(成功),0(结果位0),-1(溢出)
      
2151. *****************************************************************************************/
      
2152. 
      
2153. char divider()
      
2154. {
      
2155.   unsigned long int divisor=0,remainder=0;
      
2156.   uchar p,q,r;
      
2157.   char decimal=0;
      
2158.   if(opera[1][11]==0) return -1;
      
2159.   if(opera[0][11]==0) return 0;
      
2160.   for(r=1;r<12;r++)     // 判断两数是否相等
      
2161.   {
      
2162.     if(opera[0][r]!=opera[1][r]) break;
      
2163.   }
      
2164.   if(r==12)
      
2165.   {
      
2166.     p=opera[0][0];
      
2167.     removal_data(0,1);
      
2168.     opera[0][0]=r;
      
2169.     opera[0][1]=1;
      
2170.     opera[0][10]=2;
      
2171.     opera[0][11]=1;
      
2172.     return 1;
      
2173.   }  
      
2174.   decimal=(opera[0][11]-opera[0][10])-(opera[1][11]-opera[1][10]);
      
2175.   // 记录两操作数小数点后位数的差
      
2176.   if(decimal>0)     // 若操0大于操1时重新记录小数点的位置
      
2177.   {
      
2178.     opera[0][10]=opera[0][11]-decimal+1;
      
2179.     resu[10]=opera[0][10];
      
2180.   }
      
2181.   else      // 否则小数点后没有数，记录有效数的位数
      
2182.   {
      
2183.     opera[0][11]-=decimal;
      
2184.     opera[0][10]=opera[0][11]+1;
      
2185.     resu[10]=opera[0][10];
      
2186.   }
      
2187.   q=1;
      
2188.   divisor=0;
      
2189.   while(q<=opera[1][11]) // 将操1的数整形化
      
2190.   {
      
2191.     divisor=divisor*10+opera[1][q];q++;
      
2192.   }
      
2193.   if(divisor==1)   
      
2194.   {
      
2195.     if(resu[10]>10) return -1;
      
2196.     else return 1;
      
2197.   }
      
2198.   r=1;p=1;
      
2199.   remainder=(unsigned long int)opera[0][1]; // 先对余数寄存器附初值
      
2200.   do
      
2201.   {   
      
2202.     if(r>9)  // 结果位已经到达最后1位
      
2203.     {  
      
2204.       if(resu[1]==0&&resu[10]!=2) // 判断是否有得移位
      
2205.       {     
      
2206.         for(r=1;r<9;r++) resu[r]=resu[r+1];
      
2207.         resu[9]=0;
      
2208.         if(resu[10]!=0) resu[10]--;
      
2209.         r=9;
      
2210.       }
      
2211.       else if(p>=opera[0][11]||p>=opera[0][10])  break; // 如果计算到最后一位，或者有小数点存在时结束
      
2212.       else return -1; // 否则错误
      
2213.     }
      
2214.     resu[r]=(uchar)(remainder/divisor); // 保存结果
      
2215.     remainder=(remainder%divisor);      // 重新写入余数
      
2216.     p++;r++;     
      
2217.     if(p>opera[0][11]&&remainder==0) break; // 除尽后跳出
      
2218.     else if(p<=opera[0][11]&&p<10)      // 余数*10后加后一位
      
2219.       {remainder=remainder*10+opera[0][p];}
      
2220.     else   remainder=remainder*10;   //超出后余数*10
      
2221.   }while(1);
      
2222.   resu[11]=r-1;
      
2223.   resu[0]=opera[0][0];
      
2224.   removal_data(0,1);
      
2225.   r=1;   
      
2226.   while(resu[r]==0&&resu[10]!=(r+1)&&r<resu[11]) r++;
      
2227. //去除结果前端的0
      
2228.   if(r==resu[11]) return 0;
      
2229.   resu[10]=resu[10]-r+1;
      
2230.   p=1;
      
2231.   while(r<=resu[11]){opera[0][p]=resu[r];r++;p++;}
      
2232.   opera[0][0]=resu[0];opera[0][10]=resu[10];opera[0][11]=p-1;
      
2233.   while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0)
      
2234.     opera[0][11]--;
      
2235.   return 1;
      
2236. }
      
2237. 
      
2238. 
      
2239. /****************************************************************************************
      
2240. 功能:  加法运算
      
2241. 描述:  以小数点位中心两边相加
      
2242. 参数:  i , j , opera[ i][j],p,q,r
      
2243. 返回值：1(成功),0(结果位0),-1(溢出)
      
2244. /****************************************************************************************/
      
2245. 
      
2246. char adder()
      
2247. {
      
2248.   uchar p,q,r;
      
2249.   if(opera[0][11]==0&&opera[1][11]==0)   return 0;
      
2250.   else if(opera[0][11]==0)
      
2251.     {for(q=0;q<12;q++) opera[0][q]=opera[1][q];return 1;}
      
2252.   else if(opera[1][11]==0) return 1;
      
2253.   else
      
2254.   {
      
2255.     p=opera[0][10]-1;
      
2256.     q=opera[1][10]-1;
      
2257.     p>q?(r=p):(r=q);
      
2258.     resu[10]=r+1;       // 小数点位保存
      
2259.     resu[0]=opera[0][0];    // 保存符号位
      
2260.     while(r>0)          // 将小数点前的数相应相加后放到结果中
      
2261.     {
      
2262.       if(p>0&&q>0){resu[r]=opera[0][p]+opera[1][q];p--;q--;}
      
2263.       else if(p>0&&q==0){resu[r]=opera[0][p];p--;}
      
2264.       else  {resu[r]=opera[1][q];q--;}
      
2265.       r--;
      
2266.     }
      
2267.     r=resu[10];
      
2268.     p=opera[0][10];
      
2269.     q=opera[1][10];
      
2270.     while(r<10)         // 将小数点后的数放到结果中
      
2271.     {
      
2272.       if(p>opera[0][11]&&q>opera[1][11]) break;
      
2273.       else if(p<=opera[0][11]&&q<=opera[1][11])
      
2274.         {resu[r]=opera[0][p]+opera[1][q];p++;q++;}
      
2275.       else if(p<=opera[0][11]&&q>opera[1][11])
      
2276.         {resu[r]=opera[0][p];p++;}
      
2277.       else  {resu[r]=opera[1][q];q++;}
      
2278.       r++;
      
2279.     }
      
2280.     r--;
      
2281.     resu[11]=r;
      
2282.     p=0;
      
2283.     while(r>0)          // 由右到左将大于9的数进位
      
2284.     {
      
2285.       resu[r]+=p;           // p为进位标记
      
2286.       p=0;
      
2287.       if(resu[r]>9) {resu[r]-=10;p=1;}
      
2288.       r--;
      
2289.     }
      
2290.     if(p==1)                // 溢出移位
      
2291.     {
      
2292.       if(resu[10]==10) return -1;
      
2293.       else {
      
2294.         for(r=9;r>1;r--) resu[r]=resu[r-1];
      
2295.         resu[1]=1;resu[10]++;}
      
2296.     }
      
2297.    removal_data(0,1);
      
2298.    r=0;
      
2299.    while(r<12){opera[0][r]=resu[r];r++;}
      
2300.    while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0)
      
2301.      opera[0][11]--;
      
2302.    return 1;
      
2303.   }
      
2304. }
      
2305. 
      
2306. /****************************************************************************************
      
2307. 功能:  减法运算
      
2308. 描述:  先比较两操作数的大小用one ,two互换
      
2309. 参数:  i , j , opera[ i][j],p,q,r，one，two
      
2310. 返回值：1(成功),0(结果位0),-1(溢出)
      
2311. /****************************************************************************************/
      
2312. 
      
2313. char subtraction()
      
2314. {
      
2315.   uchar p,q,r,one,two;
      
2316.   if(opera[0][11]==0&&opera[1][11]==0)   return 0;
      
2317.   else if(opera[0][11]==0)
      
2318.   {
      
2319.     for(q=1;q<12;q++)
      
2320.     opera[0][q]=opera[1][q];
      
2321.     opera[0][0]=!opera[0][0];return 1;
      
2322.   }
      
2323.   else if(opera[1][11]==0) return 1;
      
2324.   else
      
2325.   { // 比较大小(大放到one)
      
2326.     if(opera[0][10]>opera[1][10]){one=0;two=1;}
      
2327.     else if(opera[1][10]>opera[0][10]) {one=1;two=0;}
      
2328.     else
      
2329.     {
      
2330.       r=1;
      
2331.       while(r<10&&opera[0][r]==opera[1][r]) r++;
      
2332.       if(r==10) {removal_data(0,1);return 0;}
      
2333.       opera[0][r]>opera[1][r]?(one=0,two=1):(one=1,two=0);
      
2334.     }
      
2335.     p=opera[one][10]-1;
      
2336.     q=opera[two][10]-1;
      
2337.     r=p;            // 保存小数点前的数
      
2338.     resu[10]=r+1;   // 保存小数点位
      
2339.     resu[0]=0;      // 用作借位标记
      
2340.     while(r>0)      // 小数点前相减
      
2341.     {
      
2342.       if(p>0&&q>0)
      
2343.       {
      
2344.         opera[two][q]+=resu[0];
      
2345.         resu[0]=0;
      
2346.         if(opera[one][p]>=opera[two][q])
      
2347.           resu[r]=opera[one][p]-opera[two][q];
      
2348.         else
      
2349.         {
      
2350.           resu[0]=1;
      
2351.           resu[r]=10+opera[one][p]-opera[two][q];
      
2352.         }
      
2353.         p--;q--;
      
2354.       }
      
2355.       else
      
2356.       {     
      
2357.         if(opera[one][p]<resu[0])
      
2358.           {resu[r]=10+opera[one][p]-resu[0];}
      
2359.         else
      
2360.           {resu[r]=opera[one][p]-resu[0];resu[0]=0;p--;}
      
2361.       }
      
2362.       r--;
      
2363.     }
      
2364.     r=resu[10];
      
2365.     p=opera[one][10];
      
2366.     q=opera[two][10];
      
2367.     while(r<10)     // 将小数点后的数放到结果中
      
2368.     {
      
2369.       if(p>opera[one][11]&&q>opera[two][11]) break;
      
2370.       else if(p<=opera[one][11]&&q<=opera[two][11])
      
2371.       {
      
2372.         if(opera[one][p]>=opera[two][q])  resu[r]=opera[one][p]-opera[two][q];
      
2373.         else
      
2374.         {
      
2375.           resu[r]=10+opera[one][p]-opera[two][q];
      
2376.           resu[0]=r;
      
2377.           for(r-=1;r>0;r--) // 向前借位
      
2378.           {
      
2379.             if(resu[r]==0) resu[r]=9;
      
2380.             else{resu[r]-=1;break;}
      
2381.           }
      
2382.           r=resu[0];   
      
2383.         }
      
2384.         p++;q++;
      
2385.       }                        
      
2386.       else if(p<=opera[one][11]&&q>opera[two][11])
      
2387.         {resu[r]=opera[one][p];p++;}
      
2388.       else  
      
2389.       {
      
2390.         resu[r]=10-opera[two][q];  
      
2391.         resu[0]=r;
      
2392.         for(r-=1;r>0;r--)
      
2393.         {
      
2394.           if(resu[r]==0) resu[r]=9;
      
2395.           else{ resu[r]-=1;break;}
      
2396.         }
      
2397.         r=resu[0];
      
2398.         q++;   
      
2399.       }
      
2400.       if(r==9)      // 结果溢出移位
      
2401.       {
      
2402.         if(resu[1]==0&&resu[10]!=2)
      
2403.         {
      
2404.           for(r=1;r<9;r++) resu[r]=resu[r+1];
      
2405.           resu[10]--;resu[9]=0;r=8;
      
2406.         }
      
2407.       }
      
2408.       r++;
      
2409.     }
      
2410.     r--;
      
2411.     resu[11]=r;
      
2412.     if(one==0)resu[0]=opera[0][0];  // 符号位写入
      
2413.     else resu[0]=!opera[0][0];
      
2414.     removal_data(0,1);
      
2415.     r=1;
      
2416.     while(resu[r]==0&&resu[10]!=(r+1)) r++; // 去除前端0
      
2417.     resu[10]=resu[10]-r+1;          // 重新写入小数点
      
2418.     p=1;
      
2419.     while(r<=resu[11]){opera[0][p]=resu[r];r++;p++;}
      
2420.     opera[0][0]=resu[0];opera[0][10]=resu[10];opera[0][11]=p-1;
      
2421.     while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0) opera[0][11]--;
      
2422.     return 1;
      
2423.   }
      
2424. }
      
2425. 
      
2426. 
      
2427. /****************************************************************************************
      
2428. 功能:  计算器主函数
      
2429. 描述:  根据符号位,运算符调用函数
      
2430. 参数:  state,save
      
2431. 返回值：无
      
2432. ****************************************************************************************/
      
2433. 
      
2434. 
      
2435. void calculator(void)
      
2436. {
      
2437.   char data state;
      
2438.   uchar data save;
      
2439.   save1=0;
      
2440.   dis_title_e();
      
2441.   display_cnasc(0x82,3,tool_menu[0]);
      
2442.   display_cnasc(0x96,2,"等于");
      
2443.   display_cnasc(0x8e,2,"删除");
      
2444.   display_cnasc(0x9e,2,"退出");
      
2445.   removal_data(2,0);    // 0为清除显示
      
2446.   removal_data(0,0);
      
2447.   i=0;j=1;
      
2448.   while(1)
      
2449.   {
      
2450.     cal_run=0;
      
2451.     state=input_data();
      
2452.     if(state==1)  // 根据opera[1][0]的数值调用程序
      
2453.     {
      
2454.       if(opera[1][0]==12&&opera[0][0]==0||opera[1][0]==13&&opera[0][0]==1)
      
2455.         state=adder();
      
2456.       else if(opera[1][0]==12&&opera[0][0]==1||opera[1][0]==13&&opera[0][0]==0)
      
2457.         state=subtraction();
      
2458.       else if(opera[1][0]==14) state=multiplication();
      
2459.       else state=divider();
      
2460.     }
      
2461.     if(state==0)  return;
      
2462.     i=0;j=1;
      
2463.     cal_run=1;
      
2464.     switch(state)
      
2465.     {
      
2466.       case -1:                      // 结果溢出
      
2467.               removal_data(2,0);
      
2468.               removal_data(0,0);  
      
2469.               display_cnasc(0x8a,3,"溢出!!");
      
2470.               save1=0;
      
2471.               break;
      
2472.       case  0:                      // 结果为零
      
2473.               if(save1==0)
      
2474.               {
      
2475.                 removal_data(2,1);
      
2476.                 removal_data(0,1);
      
2477.                 display_cnasc(0x98,1,"= ");
      
2478.                 display_cnasc(0x9d,1," 0");
      
2479.               }
      
2480.               break;                // 结果显示
      
2481.       case  1:
      
2482.               if(save1==0)
      
2483.               {
      
2484.                 cal_run=1;
      
2485.                 display_cnasc(0x98,1,"= ");
      
2486.                 dis_cdata(0x98);
      
2487.               }
      
2488.               break;
      
2489.     }
      
2490.     if(save1==0) save=gotkey();  // save1记录连续计算符
      
2491.     cal_run=0;  
      
2492.     if((save>11&&save<16&&state==1)||save1!=0)
      
2493.     {
      
2494.       removal_data(2,0);
      
2495.       removal_data(1,0);
      
2496.       display_cnasc(0x90,6,"               ");
      
2497.       if(opera[0][11]==0) display_cnasc(0x95,1," 0");
      
2498.       else dis_cdata(0x90);
      
2499.       if(save1!=0)save=save1;
      
2500.       save1=0;
      
2501.       display_cnasc(0x88,1,tool_cal[save-12]);
      
2502.       opera[1][0]=save;
      
2503.       i=1;j=1;
      
2504.     }
      
2505.     else if(save>=0&&save<10&&state==1)
      
2506.     {
      
2507.       removal_data(2,0);
      
2508.       removal_data(0,0);
      
2509.       opera[0][1]=save;
      
2510.       opera[0][11]++;
      
2511.       dis_cdata(0x90);
      
2512.       i=0;j=2;
      
2513.     }
      
2514.     else if(save==10)
      
2515.     {  
      
2516.       removal_data(2,0);
      
2517.       removal_data(0,0);
      
2518.       opera[ i][10]=2;
      
2519.       opera[ i][11]=1;
      
2520.       j=2;
      
2521.     }
      
2522.     else
      
2523.     {
      
2524.       removal_data(2,0);
      
2525.       removal_data(0,0);
      
2526.     }
      
2527.   }                                                     
      
2528. }
      
2529.   
      
2530. 
      
2531. /*=====================================================================================
      
2532. 函数名称：温度功能
      
2533. 功能描述：连续检查温度
      
2534. 全局变量：temprun  oth_run  als_temp  adju_si
      
2535. 参数说明：见函数
      
2536. 返回说明：无
      
2537. 设 计 人：JZHG
      
2538. 版    本：1.0
      
2539. 说    明：
      
2540. ======================================================================================*/
      
2541. 
      
2542. 
      
2543. /*温度显示*/
      
2544. uchar temp_func_dis(void)
      
2545. {
      
2546.   uchar save[2],k;
      
2547.    clear_dis();
      
2548.   dis_title_e();
      
2549.   display_cnasc(0x82,3,"温度计");  
      
2550.   display_cnasc(0x98,3,"设定");
      
2551.   display_cnasc(0x9e,3,"退出");
      
2552.   display_cnasc(0x8e,1," \x1f");
      
2553.   num2_asc_dis(10,0x85);
      
2554.   temprun=1;
      
2555.   while(1)
      
2556.   {
      
2557.     if(ds18b20)
      
2558.     {
      
2559.       if(temp.t_data[0]>99)   // 温度值大于99时
      
2560.       {
      
2561.         save[0]=temp.t_data[0]/100;
      
2562.         save[1]=(temp.t_data[0]/10)%10;
      
2563.         num2_asc_dis(save[0],0x80);
      
2564.         num2_asc_dis(save[1],0x81);
      
2565.         save[0]=char_num[temp.t_data[0]%10];
      
2566.         num2_asc_dis(save[0],0x82);
      
2567.       }
      
2568.       else                   // 温度小于100
      
2569.       {
      
2570.         con_disp(0x00,0x00,0x80,0x90,1,16);
      
2571.         con_disp(0x00,0x00,0x88,0x90,1,16);
      
2572.         if(temp_pn) con_disp(0x3f,0xfc,0x80,0x9d,1,3);
      
2573.         else  con_disp(0x00,0x00,0x80,0x9d,1,3);
      
2574.         save[0]=temp.t_data[0]/10;
      
2575.         save[1]=temp.t_data[0]%10;
      
2576.         num2_asc_dis(save[0],0x81);
      
2577.         num2_asc_dis(save[1],0x82);
      
2578.       }
      
2579.       save[0]='.';
      
2580.       save[1]=char_num[temp.t_data[1]/10];
      
2581.       display_cnasc(0x8b,1,save);
      
2582.       save[0]=char_num[temp.t_data[1]%10];
      
2583.       if(save[0]=='1') save[1]='2';        // 补偿精度
      
2584.       else if(save[0]=='7') save[1]='5';
      
2585.       else if(save[0]=='8'||save[0]=='1') save[1]='7';
      
2586.       else save[1]='0';
      
2587.       display_cnasc(0x8c,1,save);
      
2588.     }
      
2589.     else
      
2590.     {
      
2591.       clear_dis();
      
2592.       display_cnasc(0x92,4,"没有发现");
      
2593.       display_cnasc(0x8c,4,"温感器！");
      
2594.       delay_pw();
      
2595.       delay_pw();
      
2596.       delay_pw();
      
2597.       temprun=0;
      
2598.       return 0;
      
2599.     }
      
2600.     k=gotkey();
      
2601.     if(k==2)     // 进入设置菜单
      
2602.     {
      
2603.       display_cnasc(0x8e,1," \x04");
      
2604.       delay(35000);
      
2605.       display_cnasc(0x8e,1," \x1e");
      
2606.       display_cnasc(0x9a,4,"\x11 (ok) \x10");
      
2607.       return 1;
      
2608.     }
      
2609.   }
      
2610. }
      
2611. 
      
2612. /*警报温度设置*/
      
2613. uchar temp_func_set(void)
      
2614. {
      
2615.   uchar save[2];
      
2616.   temprun=0;
      
2617.   oth_run=0;
      
2618.   rds1302_data();
      
2619.   while(1)
      
2620.   {  
      
2621.     if(oth_run)
      
2622.     {
      
2623.       con_disp (0x00,0x00,0x88,0x90,2,16);
      
2624.       con_disp (0xff,0xff,0x8e,0x90,2,16);
      
2625.     }
      
2626.     else
      
2627.     {
      
2628.       con_disp (0xff,0xff,0x88,0x90,2,16);
      
2629.       con_disp (0x00,0x00,0x8e,0x90,2,16);
      
2630.     }   
      
2631.     save[0]=gotkey();
      
2632.     if(save[0]==1||save[0]==3) oth_run=!oth_run;
      
2633.     if(save[0]==5) return 1;
      
2634.     if(save[0]==11)
      
2635.     {  
      
2636.       if(oth_run) return 0;
      
2637.       else  
      
2638.       {
      
2639.         clear_dis();
      
2640.         dis_title_e();
      
2641.         save[1]=save[0]=0;
      
2642.         oth_run=0;
      
2643.         dis_title_e();
      
2644.         display_cnasc(0x82,3,"设  定");
      
2645.         display_cnasc(0x90,5,"警报温度：");
      
2646.         display_cnasc(0x88,7,"高于【    】℃");
      
2647.         display_cnasc(0x98,8,"低于【    】℃ \x10");
      
2648.         while(1)
      
2649.         {
      
2650.           if(save[1]==2) con_disp(0x00,0x00,index_temp_set[save[1]].lnum,index_temp_set[save[1]].rnum,2,13);
      
2651.           else con_disp(0x00,0x00,index_temp_set[save[1]].lnum,index_temp_set[save[1]].rnum,2,13);
      
2652.           if(save[0]==2) con_disp(0x0f,0xff,index_temp_set[save[0]].lnum,index_temp_set[save[0]].rnum,1,13);
      
2653.           else con_disp(0xff,0xff,index_temp_set[save[0]].lnum,index_temp_set[save[0]].rnum,2,13);
      
2654.           save[1]=save[0];
      
2655.           adju_si=0;
      
2656.           oth_run=0;
      
2657.           while(1)
      
2658.           {
      
2659.             for(i=0;i<2;i++)
      
2660.             {
      
2661.               j=0x8b+i*16;
      
2662.               if(als_temp[ i]==255) display_cnasc(j,2," off"); // 255值为关闭值
      
2663.               else
      
2664.               {
      
2665.                 save1=save[1];
      
2666.                 if(als_temp[ i]>127)  // 当数值大于127时温度值为负数
      
2667.                 {
      
2668.                   display_cnasc(j,1,"- ");
      
2669.                   save[0]=char_num[(als_temp[ i]-128)/10];
      
2670.                   save[1]=char_num[(als_temp[ i]-128)%10];
      
2671.                   display_cnasc(j+1,1,save);
      
2672.                 }
      
2673.                 else
      
2674.                 {
      
2675.                   save[0]=' ';
      
2676.                   save[1]=char_num[als_temp[ i]/100];
      
2677.                   if(save[1]=='0') save[1]=' ';
      
2678.                   display_cnasc(j,1,save);
      
2679.                   save[0]=char_num[als_temp[ i]/10%10];
      
2680.                   save[1]=char_num[als_temp[ i]%10];
      
2681.                   display_cnasc(j+1,1,save);
      
2682.                 }
      
2683.                 save[1]=save1;
      
2684.               }
      
2685.             }      
      
2686.             save[0]=gotkey();
      
2687.             do         // 输入符号等待数值输入或下一位
      
2688.             {
      
2689.               if(save[0]==13){ oth_run=1;display_cnasc(0x8b+save[1]*16,2,"-   ");}
      
2690.               else if(save[0]==12){ oth_run=0;display_cnasc(0x8b+save[1]*16,2,"    ");}
      
2691.               else break;
      
2692.               save[0]=gotkey();
      
2693.               if(save[0]>=0&&save[0]<10||save[0]==11) break;
      
2694.             }while(1);
      
2695.             if(save[0]==14){ als_temp[save[1]]=255;}  // 乘号直接将警报温度关闭
      
2696.             if(save[0]>=0&&save[0]<10&&save[1]<2)
      
2697.             {
      
2698.               if(adju_si)
      
2699.               {
      
2700.                 adju_si=0;
      
2701.                 if(oth_run) als_temp[save[1]]&=0x7f;  // 消去符号位
      
2702.                 if(als_temp[save[1]]>24&&!oth_run) als_temp[save[1]]=240;
      
2703.                 else als_temp[save[1]]=als_temp[save[1]]*10+save[0];
      
2704.                 if(oth_run&&als_temp[save[1]]>50) als_temp[save[1]]=50;         
      
2705.                 if(!oth_run&&als_temp[save[1]]>120) als_temp[save[1]]=120;
      
2706.                 if(!oth_run&&als_temp[save[1]]<100) adju_si=1;  // 根据数值打开连写
      
2707.                 if(oth_run&&als_temp[save[1]]<10)  adju_si=1;
      
2708.               }
      
2709.               else
      
2710.               {
      
2711.                 als_temp[save[1]]=save[0];
      
2712.                 adju_si=1;
      
2713.               }
      
2714.               if(oth_run) als_temp[save[1]]=als_temp[save[1]]|0x80;  // 写入符号
      
2715.               else als_temp[save[1]]=als_temp[save[1]]&0x7f;
      
2716.             }                  
      
2717.             if(save[0]==11)
      
2718.             {
      
2719.               if(als_temp[1]!=255&&als_temp[0]!=255)       // 上下限温度调整
      
2720.               {
      
2721.                 if(save[1]==0&&als_temp[0]<als_temp[1]){als_temp[0]=als_temp[1];}
      
2722.                 if(save[1]==1&&als_temp[1]>als_temp[0]){als_temp[1]=als_temp[0];}
      
2723.               }
      
2724.               save[0]=save[1]+1;adju_si=0;break;}
      
2725.             if(save[0]==10&&save[1]!=0) {save[0]=save[1]-1;adju_si=0;break;}
      
2726.           }
      
2727.           oth_run=0;
      
2728.           if(save[0]==3&&save[1]==2) break;
      
2729.         }
      
2730.         save_y_or_n();
      
2731.         if(oth_run)
      
2732.         {
      
2733.           wds1302_data(d02_temp,als_temp[0]);
      
2734.           wds1302_data(d02_temp+2,als_temp[1]);
      
2735.         }
      
2736.         return 1;
      
2737.       }
      
2738.     }
      
2739.   }
      
2740. }         
      
2741.                      
      
2742.          
      
2743. /*温度计主函数*/         
      
2744. void temp_func(void)
      
2745. {        
      
2746.   uchar t;  
      
2747.   while(1)
      
2748.   {
      
2749.     oth_run=1;
      
2750.     t=temp_func_dis();
      
2751.     if(t==1)
      
2752.     {
      
2753.       t=temp_func_set();
      
2754.       if(t==0) return;
      
2755.     }
      
2756.     else return;
      
2757.   }
      
2758. }
      
2759. /*=====================================================================================
      
2760. 函数名称：闹铃功能
      
2761. 功能描述：设定闹铃
      
2762. 全局变量：alarm_time adju_si
      
2763. 参数说明：见函数
      
2764. 返回说明：无
      
2765. 设 计 人：JZHG
      
2766. 版    本：1.0
      
2767. 说    明：
      
2768. ======================================================================================*/
      
2769. 
      
2770. 
      
2771. void alarm_func(void)
      
2772. {
      
2773.   uchar save[2],a,d;
      
2774.   clear_dis();
      
2775.   dis_title_e();
      
2776.   display_cnasc(0x82,3,"闹  钟");  
      
2777.   display_cnasc(0x91,6,"状态：\x11    \x10");
      
2778.   display_cnasc(0x89,3,"闹铃：");
      
2779.   display_cnasc(0x9f,1,"→");
      
2780.   display_cnasc(0x90,1,"『");
      
2781.   display_cnasc(0x8f,1,"』");
      
2782.   adju_si=0;
      
2783.   a=0;d=0;
      
2784.   save[0]=char_num[alarm_time[0]>>4];
      
2785.   save[1]=char_num[alarm_time[0]&0x0f];
      
2786.   display_cnasc(0x8c,1,save);
      
2787.   display_cnasc(0x8d,1,": ");
      
2788.   save[0]=char_num[alarm_time[1]>>4];
      
2789.   save[1]=char_num[alarm_time[1]&0x0f];
      
2790.   display_cnasc(0x8e,1,save);
      
2791.   do
      
2792.   {
      
2793.     if(a==0)
      
2794.     {   
      
2795.       display_cnasc(0x95,1,alm_sign[alm]);
      
2796.       display_cnasc(0x94,1,"\x11 ");
      
2797.       display_cnasc(0x96,1," \x10");
      
2798.       con_disp(0x00,0x00,index_alm[d-1].lnum,index_alm[d-1].rnum,1,14);
      
2799.     }
      
2800.     if(a>0&&a<4)
      
2801.     {
      
2802.       if(d==0)
      
2803.       {
      
2804.         display_cnasc(0x94,1,"  ");
      
2805.         display_cnasc(0x96,1,"  ");
      
2806.       }
      
2807.       else
      
2808.        con_disp(0x00,0x00,index_alm[d-1].lnum,index_alm[d-1].rnum,1,14);
      
2809.      con_disp(0xff,0xff,index_alm[a-1].lnum,index_alm[a-1].rnum,1,14);  
      
2810.     }         
      
2811.     d=a;
      
2812.     while(1)
      
2813.     {
      
2814.       a=gotkey();
      
2815.       if((a==1||a==3)&&d==0)
      
2816.       {
      
2817.         alm=!alm;
      
2818.         if(a==1) display_cnasc(0x94,1,"\x09 ");
      
2819.         else display_cnasc(0x96,1," \x09");
      
2820.         delay(35000);
      
2821.         if(a==1) display_cnasc(0x94,1,"\x11 ");
      
2822.         else display_cnasc(0x96,1," \x10");
      
2823.         display_cnasc(0x95,1,alm_sign[alm]);
      
2824.       }
      
2825.       if(d>0&&d<3&&a>=0&&a<10)
      
2826.       {
      
2827.         if(adju_si)
      
2828.         {
      
2829.           alarm_time[d-1]<<=4;alarm_time[d-1]+=a;
      
2830.           if(d==1&&alarm_time[0]>0x23) alarm_time[0]=a;
      
2831.           else if(d==2&&alarm_time[1]>0x59) alarm_time[1]=a;
      
2832.           else adju_si=0;
      
2833.         }
      
2834.         else  
      
2835.         {
      
2836.           alarm_time[d-1]=a;adju_si=1;
      
2837.         }
      
2838.         save[0]=char_num[alarm_time[d-1]>>4];
      
2839.         save[1]=char_num[alarm_time[d-1]&0x0f];
      
2840.         display_cnasc(0x8c+(d-1)*2,1,save);
      
2841.       }
      
2842.       if(a==11){a=d+1;break;}
      
2843.       if(a==10&&d!=0){a=d-1;break;}
      
2844.     }
      
2845.     adju_si=0;
      
2846.     if(a==4)
      
2847.     {
      
2848.       save_y_or_n();
      
2849.       wds1302_data(d02_signs,signs);
      
2850.       wds1302_data(d02_alm,alarm_time[0]);
      
2851.       wds1302_data(d02_alm+2,alarm_time[1]);
      
2852.       return;
      
2853.     }
      
2854.   }while(1);
      
2855. }
      
2856. 
      
2857. 
      
2858. 
      
2859. /*=====================================================================================
      
2860. 函数名称：篮球器功能
      
2861. 功能描述：分数  时间  24秒  
      
2862. 全局变量：resu  opera
      
2863. 参数说明：见函数
      
2864. 返回说明：无
      
2865. 设 计 人：JZHG
      
2866. 版    本：1.0
      
2867. 说    明：
      
2868. ======================================================================================*/
      
2869. 
      
2870. /*比赛设置*/
      
2871. void nba_set(void)
      
2872. {
      
2873.   uchar nba,save1,key,save[2];
      
2874.   clear_dis();
      
2875.   dis_title_e();
      
2876.   if(resu[7]==1) display_cnasc(0x82,3,"加  时");
      
2877.   else  
      
2878.   {
      
2879.     display_cnasc(0x82,3,"设  定");
      
2880.     opera[0][0]=0;
      
2881.     opera[1][0]=1;
      
2882.   }
      
2883.   resu[6]=0;    // 赋初值
      
2884.   resu[0]=1;
      
2885.   resu[1]=4;
      
2886.   resu[2]=12;
      
2887.   resu[3]=0;
      
2888.   resu[4]=24;
      
2889.   display_cnasc(0x90,7,"队1:红  队2:白");
      
2890.   display_cnasc(0x88,7,"24秒:Y  节数:4");
      
2891.   display_cnasc(0x98,8,"每节时间: 12分钟");
      
2892.   save1=0;nba=0;
      
2893.   while(1)
      
2894.   {
      
2895.     if(save1==4) display_cnasc(0x9c,1,":");
      
2896.     else display_cnasc(index_nba[save1],1,"  ");
      
2897.     if(nba==4)  display_cnasc(0x9c,1,":\x10");
      
2898.     else display_cnasc(index_nba[nba],1,"\x11 ");
      
2899.     save1=nba;
      
2900.     key=gotkey();   
      
2901.     if(key==1||key==3)
      
2902.     {     
      
2903.       switch(nba)     // 导航更改数据
      
2904.       {
      
2905.         case 0:            
      
2906.         case 1:
      
2907.                 if(key==1){if(opera[nba][0]>0) opera[nba][0]--;
      
2908.                            else opera[nba][0]=7;}
      
2909.                 if(key==3){if(opera[nba][0]<7) opera[nba][0]++;
      
2910.                            else opera[nba][0]=0;}
      
2911.                 display_cnasc(index_nba[nba]-1,1,nba_oppo[opera[nba][0]]);
      
2912.                 break;
      
2913.         case 2:
      
2914.                 if(resu[0]>0) resu[0]=0;
      
2915.                 else resu[0]=1;
      
2916.                 if(resu[0]>0)   display_cnasc(0x8a,1,":Y");
      
2917.                 else display_cnasc(0x8a,1,":N");
      
2918.                 break;
      
2919.         case 3:
      
2920.                 if(key==1){if(resu[1]>1) resu[1]--;
      
2921.                             else  resu[1]=4;}
      
2922.                 if(key==3){if(resu[1]<4) resu[1]++;
      
2923.                            else resu[1]=1;}
      
2924.                 save[0]=':';
      
2925.                 save[1]=char_num[resu[1]];
      
2926.                 display_cnasc(0x8e,1,save);
      
2927.                 break;
      
2928.         case 4:
      
2929.                 if(key==1){if(resu[2]>0) resu[2]--;
      
2930.                             else  resu[2]=60;}
      
2931.                 if(key==3){if(resu[2]<60) resu[2]++;
      
2932.                            else resu[2]=0;}
      
2933.                 save[0]=char_num[resu[2]/10];
      
2934.                 save[1]=char_num[resu[2]%10];
      
2935.                 display_cnasc(0x9d,1,save);
      
2936.                 resu[5]=resu[2];
      
2937.                 break;
      
2938.       }
      
2939.     }
      
2940.     if(key==11)
      
2941.     {
      
2942.       nba++; if(nba==5) return;            
      
2943.     }
      
2944.     if(key==10&&nba!=0)  nba--;
      
2945.   }
      
2946. }
      
2947. 
      
2948. 
      
2949. 
      
2950. /*界面其他元素*/
      
2951. void nba_oth_dis(void)
      
2952. {
      
2953.   uchar save[2];
      
2954.   if(resu[7]==1) display_cnasc(0x80,5,"加时时间：");
      
2955.   else display_cnasc(0x80,5,"比赛时间：");
      
2956.   display_cnasc(0x98,1,nba_oppo[opera[0][0]]);
      
2957.   display_cnasc(0x9e,1,nba_oppo[opera[1][0]]);
      
2958.   display_cnasc(0x99,1,"队");
      
2959.   display_cnasc(0x9f,1,"队");
      
2960.   save[0]='0';
      
2961.   save[1]=char_num[resu[6]+1];
      
2962.   display_cnasc(0x9b,1,save);
      
2963.   display_cnasc(0x9c,1,"st");
      
2964.   con_disp(0xff,0xff,0x83,0x90,2,1); // 画正方框
      
2965.   con_disp(0xff,0xff,0x8b,0x8f,2,1);
      
2966.   con_disp(0x80,0x00,0x83,0x91,1,15);
      
2967.   con_disp(0x00,0x01,0x84,0x91,1,15);
      
2968.   con_disp(0x80,0x00,0x8b,0x80,1,15);
      
2969.   con_disp(0x00,0x01,0x8c,0x80,1,15);
      
2970.   nba_dis_time();
      
2971.   if(resu[0]==0) display_cnasc(0x93,2,"\x07--\x07");
      
2972.   display_cnasc(0x8b,2," S! ");
      
2973. }
      
2974. 
      
2975. 
      
2976. 
      
2977. /*篮球器主函数*/
      
2978. void nba_timer(void)
      
2979. {
      
2980.   uchar save,key,nba=0;
      
2981.   als=di0=1;alm=keb=di1=oth_run=0;
      
2982.   time_init();  
      
2983.   display_cnasc(0x82,3,"篮球器");
      
2984.   dis_title_e();
      
2985.   removal_data(0,1);
      
2986.   while(1)    // 使用说明
      
2987.   {
      
2988.     display_cnasc(0x90,8,timer_tips[nba]);
      
2989.     display_cnasc(0x88,8,timer_tips[nba+1]);
      
2990.     display_cnasc(0x98,8,timer_tips[nba+2]);
      
2991.     key=gotkey();
      
2992.     if(key==11)
      
2993.     {
      
2994.       nba+=3;
      
2995.       if(nba>9) break;
      
2996.     }
      
2997.     if(key==10)
      
2998.     {
      
2999.       if(nba>0) nba-=3 ;
      
3000.     }
      
3001.   }
      
3002. nn:
      
3003.   nba_set();
      
3004.   clear_dis();
      
3005.   nba_oth_dis();
      
3006.   nba_tim=1;
      
3007.   while(1)
      
3008.   {
      
3009.     for(save=0x80,nba=0;nba<2;nba++)
      
3010.     {
      
3011.       if(opera[nba][1]>99)  // 分数显示
      
3012.       {
      
3013.         num2_asc_dis(opera[nba][1]/100,save);
      
3014.         num2_asc_dis(opera[nba][1]/10%10,save+1);
      
3015.         num2_asc_dis(opera[nba][1]%10,save+2);
      
3016.       }
      
3017.       else
      
3018.       {
      
3019.         num2_asc_dis(opera[nba][1]/10,save);
      
3020.         num2_asc_dis(opera[nba][1]%10,save+1);
      
3021.       }
      
3022.       if(opera[1][1]>99) save=0x85;
      
3023.       else save=0x86;
      
3024.     }
      
3025.    
      
3026.     do
      
3027.     {
      
3028.     key=gotkey();
      
3029.   ss:
      
3030.     switch(key)
      
3031.     {
      
3032.       case 12:
      
3033.       case 13:
      
3034.                if(key==12)
      
3035.                  {if(opera[0][1]<250) opera[0][1]++;}
      
3036.                else
      
3037.                  {if(opera[0][1]>0) opera[0][1]--;}
      
3038.                save=110;
      
3039.                break;
      
3040.       case 14:
      
3041.       case 15:
      
3042.                if(key==14)
      
3043.                  {if(opera[1][1]<250) opera[1][1]++;}
      
3044.                else
      
3045.                  {if(opera[1][1]>0) opera[1][1]--;}
      
3046.                save=110;
      
3047.                break;
      
3048.       case  7:
      
3049.                TR1=TR0=EA=0;
      
3050.                if((++resu[3])>59)
      
3051.                {
      
3052.                  resu[3]=0;
      
3053.                  if((++resu[2])>59)
      
3054.                  {
      
3055.                    resu[3]=0;
      
3056.                    if(++resu[2]>60) resu[2]=0;
      
3057.                  }
      
3058.                }
      
3059.                if(resu[4]<24) resu[4]++;
      
3060.                nba_dis_time();
      
3061.                break;
      
3062.       case  8:
      
3063.                if(resu[0]==1)
      
3064.                {
      
3065.                  TL1=(time_count&0x00FF);
      
3066.                  TH1=(time_count>>8);
      
3067.                  resu[4]=24; nba_dis_time();
      
3068.                  TR0=TR1=EA=1;
      
3069.                }
      
3070.                break;
      
3071.       case  9:
      
3072.                if(resu[2]==0&&resu[3]==0)
      
3073.                {
      
3074.                  resu[2]=resu[5];resu[4]=24;
      
3075.                  if(resu[6]==resu[1])
      
3076.                  {                            // 判断比分进行加时赛
      
3077.                    if(opera[0][1]==opera[1][1]){nba_tim=0;resu[7]=1; goto nn;}
      
3078.                    while(gotkey()!=10);       // 否则只能退出
      
3079.                    signs=r1302(d02_signs+1);
      
3080.                    nba_tim=0;
      
3081.                    return;
      
3082.                  }
      
3083.                  else nba_oth_dis();
      
3084.                  break;
      
3085.                }
      
3086.                if(EA) {TR0=TR1=EA=0;break;}
      
3087.                if(!EA&resu[4]!=0){ EA=TR0=1;if(resu[0]==1) TR1=1;}
      
3088.                break;                                                                           
      
3089.       case 10:
      
3090.       case 11:
      
3091.                if(!EA)          // 暂停状态下 ok键两次返回时钟界面
      
3092.                {                //  ./s 键两次退出
      
3093.                  delay(6000);
      
3094.                  save=gotkey();
      
3095.                  if(save==key)
      
3096.                  {
      
3097.                    if(key==11)
      
3098.                    {
      
3099.                      clear_dis();oth_run=1;
      
3100.                      rds1302_time();
      
3101.                      init_d2=1;
      
3102.                      dis_mode2();
      
3103.                      init_d2=0;
      
3104.                      while(gotkey()!=11);
      
3105.                      oth_run=0;
      
3106.                      save=110;
      
3107.                      clear_dis();
      
3108.                      nba_oth_dis();
      
3109.                    }
      
3110.                    else{ signs=r1302(d02_signs+1); nba_tim=0;return;}
      
3111.                  }
      
3112.                  else{ key=save;goto ss;}
      
3113.                }
      
3114.                break;     
      
3115.     }
      
3116.     if(save==110)  break;
      
3117.     }while(1);  
      
3118.   }  
      
3119. }
      
3120. 
      
3121.      
      
3122. /*=====================================================================================
      
3123. 函数名称：设置功能
      
3124. 功能描述：系统状态设置  
      
3125. 全局变量：signs
      
3126. 参数说明：见函数
      
3127. 返回说明：无
      
3128. 设 计 人：JZHG
      
3129. 版    本：1.0
      
3130. 说    明：
      
3131. ======================================================================================*/
      
3132. 
      
3133. 
      
3134. /*设置调整内容 参数格式：选中设置项，设置项子值*/
      
3135. uchar set_dis(uchar menu,uchar sub)
      
3136. {
      
3137.   uchar save;
      
3138.   con_disp(0xff,0xff,0x8e,0x80,2,16);
      
3139.   con_disp(0x00,0x00,0x8a,0x80,4,16);
      
3140.   display_cnasc(0x96,1,"\x1e ");
      
3141.   display_cnasc(0x9e,1,"\x1f ");
      
3142.   display_cnasc(0x92,1,"  ");
      
3143.   display_cnasc(0x9a,1,"  ");
      
3144.   display_cnasc(0x8d,1,"\x11 ");
      
3145.   display_cnasc(0x8a,1,"  ");
      
3146.   while(1)
      
3147.   {
      
3148.    
      
3149.     if(menu<2)
      
3150.       display_cnasc(0x8e,2,set_bl_dm[menu][sub]);
      
3151.     else
      
3152.       display_cnasc(0x8e,2,set_mka[menu-2][sub]);
      
3153.     save=gotkey();
      
3154.     if(save==5)
      
3155.     {
      
3156.       key_dis(0x96);
      
3157.       if(sub==0&&menu<2) sub=2;
      
3158.       else if(sub==0&&menu>1) sub=1;
      
3159.       else sub--;
      
3160.     }
      
3161.     if(save==2)
      
3162.     {
      
3163.       key_dis(0x9e);
      
3164.       if(sub==2&&menu<2) sub=0;
      
3165.       else if(sub==1&&menu>1) sub=0;
      
3166.       else sub++;
      
3167.     }
      
3168.     if(save==1||save==11)
      
3169.     {
      
3170.       display_cnasc(0x8d,1,"\x04 ");
      
3171.         delay(30000);
      
3172.       con_disp(0x00,0x00,0x8e,0x80,2,16);
      
3173.       con_disp(0xff,0xff,0x8a,0x80,4,16);
      
3174.       display_cnasc(0x92,1,"\x1e ");
      
3175.       display_cnasc(0x9a,1,"\x1f ");
      
3176.       display_cnasc(0x96,1,"  ");
      
3177.       display_cnasc(0x9e,1,"  ");
      
3178.       display_cnasc(0x8a,1,"【");
      
3179.       display_cnasc(0x8d,3,"】\x10 \x04 ");
      
3180.       return(sub);    // 返回设置值
      
3181.     }
      
3182.   }
      
3183. }
      
3184. 
      
3185. 
      
3186. /*设置调整*/
      
3187. void set_func(void)
      
3188. {
      
3189.   uchar d,key,save;
      
3190.   display_cnasc(0x81,2,"设置");
      
3191.   dis_title();
      
3192.   display_cnasc(0x88,8,selected[1]);
      
3193.   con_disp(0xff,0xff,0x8a,0x80,4,16);
      
3194.   save=d=0;
      
3195.   do
      
3196.   {   
      
3197.     display_cnasc(0x93,2,set_menu[index_s[save].lnum]);
      
3198.     display_cnasc(0x8b,2,set_menu[save]);
      
3199.     display_cnasc(0x9b,2,set_menu[index_s[save].rnum]);
      
3200.     d=save;
      
3201.     while(1)
      
3202.     {
      
3203.       key=gotkey();
      
3204.       if(key==11||key==3){ enter_dis();break;}
      
3205.       if(key==5){save=index_s[d].lnum;key_dis(0x92); break;}
      
3206.       if(key==2){save=index_s[d].rnum;key_dis(0x9a); break;}
      
3207.       if(key==1){ wds1302_data(d02_signs,signs); return;}
      
3208.     }
      
3209.     if(key==11||key==3)
      
3210.     {
      
3211.       save=0;
      
3212.       for(key=0;key<2;key++)  //  进行两次比较 首次为现时值 其次为设定置更改
      
3213.       {
      
3214.         switch(d)
      
3215.         {
      
3216.           case 0:
      
3217.                   if(key==1)
      
3218.                   {
      
3219.                     bl0=bl1=0;
      
3220.                     if(save==1) bl0=1;
      
3221.                     if(save==2) bl1=1;
      
3222.                   }
      
3223.                   else
      
3224.                   {if(bl0) save=1; if(bl1) save=2;}
      
3225.                   if(bl1) lcd_bl=close;
      
3226.                   else lcd_bl=open;
      
3227.                   break;
      
3228.           case 1:
      
3229.                   if(key==1)
      
3230.                   {
      
3231.                     di0=di1=0;
      
3232.                     if(save==1) di0=1;
      
3233.                     if(save==2) di1=1;
      
3234.                   }
      
3235.                   else {if(di0) save=1; if(di1) save=2;}
      
3236.                   break;
      
3237.           case 2:
      
3238.                   if(key==1) meu=(bit)save;
      
3239.                   else {if(meu) save++;}         
      
3240.                   break;
      
3241.           case 3:
      
3242.                   if(key==1) keb=(bit)save;
      
3243.                   else{if(keb) save++;}      
      
3244.                   break;
      
3245.           case 4:
      
3246.                   if(key==1) als=(bit)save;
      
3247.                   else{if(als) save++;}      
      
3248.                   break;
      
3249.           case 5: wds1302_data(d02_signs,signs);
      
3250.                   return;
      
3251.         }
      
3252.         if(key==0) save=set_dis(d,save);
      
3253.       }
      
3254.       save=d;
      
3255.     }
      
3256.   }while(1);
      
3257. }
      
3258. 
      
3259. 
      
3260. /*=====================================================================================
      
3261. 函数名称：保密功能
      
3262. 功能描述：系统重设  密码锁  密码更改  
      
3263. 全局变量：resu  
      
3264. 参数说明：见函数
      
3265. 返回说明：无
      
3266. 设 计 人：JZHG
      
3267. 版    本：1.0
      
3268. 说    明：
      
3269. ======================================================================================*/
      
3270. 
      
3271. 
      
3272. /*密码整理*/
      
3273. void passwork_finish()
      
3274. {
      
3275.   uchar i;
      
3276.   for(i=0;i<6;i+=2)
      
3277.   {
      
3278.     resu[ i]<<=4;
      
3279.     resu[ i]+=resu[i+1];
      
3280.   }
      
3281. }
      
3282. 
      
3283. 
      
3284. 
      
3285. /*读取密码*/
      
3286. uchar input_passwork()
      
3287. {
      
3288.   uchar i,save[2];
      
3289.   save[0]=' ';
      
3290.   display_cnasc(0x9d,3,"(./S)\x10");
      
3291.   for(i=0;i<6;i++)
      
3292.   {
      
3293.     while(1)
      
3294.     {
      
3295.       resu[ i]=gotkey();
      
3296.       if(resu[ i]>=0&&resu[ i]<10) break;
      
3297.       if(resu[ i]==10) return 10;
      
3298.     }
      
3299.     save[1]=char_num[resu[ i]];
      
3300.     display_cnasc(0x89+i,1,save);
      
3301.     delay(20000);
      
3302.     display_cnasc(0x89+i,1," *");
      
3303.   }
      
3304.   return 11;
      
3305. }
      
3306. 
      
3307. 
      
3308. 
      
3309. /*密码确认*/
      
3310. void input_second_passwork()
      
3311. {
      
3312.   uchar i,save[2];
      
3313.   save[0]=' ';
      
3314.   display_cnasc(0x89,6,"            ");
      
3315.   for(i=0;i<6;i++)
      
3316.   {   
      
3317.     if(resu[ i]!=gotkey())   break;
      
3318.     save[1]=char_num[resu[ i]];
      
3319.     display_cnasc(0x89+i,1,save);
      
3320.     delay(20000);
      
3321.     display_cnasc(0x89+i,1," *");
      
3322.   }
      
3323.   if(i!=6)
      
3324.   {
      
3325.     display_cnasc(0x89,6,"密码不相同！");
      
3326.     delay(50000);
      
3327.     display_cnasc(0x9a,6,"任意键 \x10    ");
      
3328.     while(gotkey()==0xf0);
      
3329.     return;
      
3330.   }
      
3331.   else
      
3332.   {
      
3333.     passwork_finish();
      
3334.     for(i=0;i<6;i+=2)
      
3335.       wds1302_data(d02_passw+i,resu[ i]);
      
3336.     for(i=0;i<6;i+=2)
      
3337.       if(resu[ i]!=r1302(d02_passw+i+1)) break;
      
3338.     if(i==6)
      
3339.      {display_cnasc(0x98,8,"\x10 更改成功!(OK) ");
      
3340.       while(gotkey()!=11);return;}
      
3341.     else
      
3342.       display_cnasc(0x9a,6,"更改失败！  ");
      
3343.   }
      
3344.   delay_pw();
      
3345. }               
      
3346. 
      
3347. 
      
3348. 
      
3349. /*密码比较*/
      
3350. uchar passwork_comp()
      
3351. {
      
3352.   uchar i;
      
3353.   passwork_finish();
      
3354.   for(i=0;i<6;i+=2)
      
3355.     if(resu[ i]!=r1302(d02_passw+i+1)) break;
      
3356.   if(i==6)   return 1;
      
3357.   else
      
3358.   {
      
3359.     display_cnasc(0x89,6,"  密码错误！");
      
3360.     delay_pw();
      
3361.     display_cnasc(0x89,6,"            ");
      
3362.     return 110;
      
3363.   }
      
3364. }
      
3365. 
      
3366. 
      
3367. 
      
3368. 
      

复制代码

接上面：

1. /*保密导航*/
   
2. void passw_func(void)
   
3. {
   
4.   uchar save,d,key;
   
5.   d=0;save=0;
   
6.   do
   
7.   {
   
8.     clear_dis();
   
9.     display_cnasc(0x81,2,"保密");
   
10.     dis_title();
    
11.     display_cnasc(0x88,8,selected[0]);
    
12.     con_disp(0xff,0xff,0x8a,0x80,5,16);
    
13.     do
    
14.     {     
    
15.       display_cnasc(0x93,3,secrets_menu[index_p[save].lnum]);
    
16.       display_cnasc(0x8b,3,secrets_menu[save]);
    
17.       display_cnasc(0x9b,3,secrets_menu[index_p[save].rnum]);  
    
18.       d=save;
    
19.       while(1)
    
20.       {
    
21.         key=gotkey();
    
22.         if(key==11||key==3){enter_dis();break;}
    
23.         if(key==2){save=index_p[d].rnum; key_dis(0x9a);break;}
    
24.         if(key==5){save=index_p[d].lnum; key_dis(0x92);break;}
    
25.         if(key==1){return;}
    
26.       }
    
27.       if(key==11||key==3)
    
28.       {
    
29.         if(d==3) return;        
    
30.         clear_dis();
    
31.         dis_title_e();
    
32.         switch(d)
    
33.         {
    
34.           case 0:
    
35.                   display_cnasc(0x82,3,"密码锁");
    
36.                   display_cnasc(0x90,5,"输入密码：");
    
37.                   while(1)
    
38.                   {
    
39.                     key=input_passwork();
    
40.                     if(key==10) break;
    
41.                     key=passwork_comp();
    
42.                     if(key==1)
    
43.                     {
    
44.                       display_cnasc(0x90,8,"处开启状态，按键");
    
45.                       display_cnasc(0x88,8,"□1-常开□2-关闭");
    
46.                       display_cnasc(0x98,8,"■自动延时30秒  ");
    
47.                       pw_oc=open;
    
48.                       save1=i=0;   
    
49.                       lock_op=1;   // 开启标记等待延时
    
50.                       while(1)
    
51.                       {
    
52.                         key=gotkey(); // 返回255为延时时间到达
    
53.                         if(key==255){ lock_op=0;pw_oc=close;break;}
    
54.                         if(key==1)
    
55.                         {
    
56.                           display_cnasc(0x88,1,"■");
    
57.                           display_cnasc(0x98,1,"□");
    
58.                           lock_op=0;
    
59.                         }
    
60.                         if(key==2)
    
61.                         {
    
62.                           display_cnasc(0x88,1,"□");
    
63.                           display_cnasc(0x98,1,"□");
    
64.                           display_cnasc(0x8c,1,"■");
    
65.                           delay(60000);
    
66.                           clear_dis();
    
67.                           dis_title_e();
    
68.                           display_cnasc(0x82,3,"密码锁");
    
69.                           display_cnasc(0x90,5,"密码锁将在");
    
70.                           display_cnasc(0x8a,6," 5秒后关闭：");
    
71.                           for(save=0;save<5;save++)
    
72.                           {
    
73.                             display_cnasc(0x99+save,1,"→");
    
74.                             delay_pw();
    
75.                           }
    
76.                           display_cnasc(0x9e,1,"√");
    
77.                           pw_oc=open;
    
78.                           delay(30000);
    
79.                           pw_oc=close;
    
80.                           lock_op=0;
    
81.                           break;
    
82.                         }
    
83.                       }
    
84.                       break;
    
85.                     }
    
86.                   }
    
87.                   break;
    
88.           case 1:
    
89.                   display_cnasc(0x82,3,"更  改");
    
90.                   display_cnasc(0x90,6,"输入旧密码：");
    
91.                   while(1)
    
92.                   {
    
93.                     key=input_passwork();
    
94.                     if(key==10) break;
    
95.                     key=passwork_comp();
    
96.                     if(key==1)
    
97.                     {
    
98.                       display_cnasc(0x92,1,"新");
    
99.                       display_cnasc(0x89,6,"            ");
    
100.                       key=input_passwork();
     
101.                       if(key==10) break;
     
102.                       display_cnasc(0x90,6,"确认密码：  ");
     
103.                       input_second_passwork();
     
104.                       break;            
     
105.                     }
     
106.                   }
     
107.                   break;
     
108.           case 2:
     
109.                   display_cnasc(0x82,3,"初始化");
     
110.                   display_cnasc(0x91,6,"是否初始化? ");
     
111.                   display_cnasc(0x89,6,"Y(OK)\\N(./S)");
     
112.                   while(1)
     
113.                   {
     
114.                     key=gotkey();
     
115.                     if(key==11)
     
116.                         {
     
117.                       clear_dis();
     
118.                       dis_title_e();
     
119.                       display_cnasc(0x82,3,"初始化");
     
120.                       display_cnasc(0x90,5,"输入密码：");
     
121.                       do
     
122.                       {
     
123.                         key=input_passwork();
     
124.                         if(key==10) break;
     
125.                         key=passwork_comp();
     
126.                         if(key==1)
     
127.                         {
     
128.                           display_cnasc(0x90,5,"密码正确！");
     
129.                           display_cnasc(0x89,7,"\x10 初始化中... ");
     
130.                           init_ds1302();
     
131.                           rds1302_data();
     
132.                           delay_pw();
     
133.                           display_cnasc(0x9a,6,"\x10 完成！(OK)");
     
134.                           while(gotkey()!=11);
     
135.                           key=10;
     
136.                           break;
     
137.                         }
     
138.                       }while(1);
     
139.                         }
     
140.                     if(key==10) break;
     
141.                   }
     
142.                   break;
     
143.         }
     
144.         key=99;save=d;
     
145.       }
     
146.       if(key==99) break;
     
147.     }while(1);
     
148.   }while(1);
     
149. }
     
150. 
     
151. 
     
152. /*=====================================================================================
     
153. 函数名称：版本信息
     
154. 功能描述：  
     
155. 全局变量：
     
156. 参数说明：见函数
     
157. 返回说明：无
     
158. 设 计 人：JZHG
     
159. 版    本：1.0
     
160. 说    明：
     
161. ======================================================================================*/
     
162. 
     
163. void version_func(void)
     
164. {
     
165.   uchar save,v=0;
     
166.   display_cnasc(0x82,3,"版  本");
     
167.   dis_title_e();
     
168.   do
     
169.   {
     
170.     display_cnasc(0x90,8,version[v]);
     
171.     display_cnasc(0x88,8,version[v+1]);
     
172.     display_cnasc(0x98,8,version[v+2]);
     
173.     if(v!=0) display_cnasc(0x97,1," \x1e");
     
174.     else if(v==0)
     
175.       display_cnasc(0x97,1,"院");
     
176.     else display_cnasc(0x97,1,"  ");
     
177.     if(v!=7) display_cnasc(0x9f,1," \x1f");
     
178.     else display_cnasc(0x9f,1,"  ");
     
179.     save=gotkey();
     
180.     if(save==2&&v<7)
     
181.     {
     
182.       display_cnasc(0x9f,1," \x04");
     
183.       delay(30000);
     
184.       v++;
     
185.     }
     
186.     if(save==5&&v>0)
     
187.     {
     
188.       display_cnasc(0x97,1," \x04");
     
189.       delay(30000);
     
190.       v--;
     
191.     }
     
192.     if(save==1) return;
     
193.     if((save==11||save==3)&&v==7)
     
194.     {
     
195.       display_cnasc(0x9e,2,") \x09 ");
     
196.       delay(30000);
     
197.       return;     
     
198.     }
     
199.   }while(1);
     
200. }
     
201. 
     
202. 
     
203. 
     
204. /*=====================================================================================
     
205. 函数名称：系统主函数
     
206. 功能描述：  
     
207. 全局变量：
     
208. 参数说明：见函数
     
209. 返回说明：无
     
210. 设 计 人：JZHG
     
211. 版    本：1.0
     
212. 说    明：
     
213. ======================================================================================*/
     
214. void main()
     
215. {
     
216.   uchar key,ys;                          
     
217.   init_lcd();                         // 初始化lcd
     
218.   lcd_bl=als_tl=als_th=buzzer=pw_oc=close;
     
219.   key=r1302(d02_initsi+1);            // 读出1302初始化标记位
     
220.   if(bl1) lcd_bl=close;
     
221.   else lcd_bl=open;
     
222.   for(ys=8;ys>0;ys--)
     
223.   {
     
224.       display_cnasc(0x92,4,"志高电子");   // 显示开机画面“志高电子”
     
225.       display_cnasc(0x9d,3,"—JZHG");
     
226.       delay_pw();
     
227.   }
     
228.   if(key!=0xb4)  init_ds1302();       // DS1302初始化
     
229.   rds1302_data();                     // 开机读回设置数据
     
230.   rds1302_date();
     
231.   rds1302_time();                     // 读日期时间   
     
232.   if(!ds18b20) init_ds18b20();        // 初始化18b20
     
233.   if(ds18b20)
     
234.   {                                 
     
235.     ds18b20_func();                    // 读出温度
     
236.   }
     
237.   time_init();                         // 定时器初始化
     
238.   delay_pw();resu[11]=0;
     
239.   while(1)
     
240.   {  
     
241.     EA=1;
     
242.     TR0=1;
     
243.     dis_sig=1;  
     
244.     clear_dis();
     
245.     if(di0){init_d2=1;dis_mode2();init_d2=0;}
     
246.     else if(di1) dis_mode3();
     
247.     else dis_mode1();   
     
248.     do
     
249.     {
     
250.       key=gotkey();
     
251.       if(key==255)          // 键盘密码输入
     
252.       {
     
253.         TR0=0;
     
254.         dis_sig=0;
     
255.         clear_dis();
     
256.         dis_title_e();
     
257.         display_cnasc(0x82,3,"键盘锁");
     
258.         display_cnasc(0x90,5,"输入密码：");
     
259.         while(1)
     
260.         {
     
261.           keb=0;
     
262.           key=input_passwork();
     
263.           if(key==10) {keb=1;resu[11]=2;break;}
     
264.           key=passwork_comp();
     
265.           if(key==1) {keb=1;resu[11]=0;break;}   
     
266.         }
     
267.         rds1302_date();
     
268.         rds1302_time();
     
269.         save_time=now;
     
270.         break;
     
271.       }
     
272.       if(key==11)
     
273.       {
     
274.         dis_menu_key(1);
     
275.         delay(35000);
     
276.         do
     
277.         {
     
278.           dis_sig=0;
     
279.           TR0=0;
     
280.           clear_dis();
     
281.           key=dis_menu();
     
282.           clear_dis();
     
283.           if(key==0) adjust_func();
     
284.           else if(key==1) // 调用相应程序功能S
     
285.           {
     
286.             while(1)
     
287.             {
     
288.               clear_dis();
     
289.               key=tool_func();
     
290.               if(key==4) break;
     
291.               clear_dis();
     
292.               switch(key)
     
293.               {
     
294.                 case 0: calculator();
     
295.                         break;
     
296.                 case 1: temp_func();
     
297.                         break;
     
298.                 case 2: alarm_func();
     
299.                         break;
     
300.                 case 3: nba_timer();
     
301.                         break;
     
302.               }
     
303.             }
     
304.           }
     
305.           else if(key==2)   set_func();
     
306.           else if(key==3)   passw_func();
     
307.           else if(key==4) version_func();
     
308.           else
     
309.           {
     
310.             rds1302_date();
     
311.             rds1302_time();
     
312.             save_time=now;
     
313.             resu[11]=0;
     
314.             dis_sig=1;
     
315.             break;
     
316.           }
     
317.         }while(1);
     
318.       }
     
319.       if(dis_sig) break;
     
320.     }while(1);
     
321.   }
     
322. }

复制代码

支持老师，很少见了

支持老师，很少见了

支持

支持

支持

挺好的

希望更多资料，嘿嘿

呵呵很好值得学习

精致的源代码。感谢

很喜欢。。。。

xiaoyao 发表于 2014-12-16 17:02
接上面：

好好看看   拿走了  谢谢楼主

真是学习的好资料，谢谢分享

确实是好资料！！要是是仿真图就好了，不知道为什么要用矩形键盘

nice！！！！

楼主：你应该把程序写成模块的，这样看会简介明了，你这样写有点乱

顶起，，，

数码管能用吗

我要攒

怎么用不了呢

真利害，谢谢分享。

多谢了 谢谢分享

看看产学习学习

好东西。

好东西。

厉害，支持

很好很好

初始密码多少

谢谢分享。

从开始到结尾多少行呀，看得好累呢，要是模块化就好了

很厉害

我用STC89C516RD+单片机运行此程序，时间和日期不走，设置了也不走，希望支持

我用STC89C516RD+单片机运行此程序，时间和日期不走，调整保存成功后也不行，希望支持

学习啦