求个LCD12864.H的液晶模块驱动包。求大神们帮助。

466246294

求个LCD12864.H的液晶模块驱动包。  

devcang

这个不如直接问液晶的厂商。   不同品牌，会有出入；用途功能不同，也会有不同的写法。

HeP028

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

复制代码

论坛里的代码，说是很强大没试过

466246294

HeP028 发表于 2012-10-26 16:44
论坛里的代码，说是很强大没试过

亲，谢谢了。