找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
12
返回列表 发新帖
楼主: 020hub
收起左侧

单片机12864液晶LCD图文菜单显示控制系统程序

  [复制链接]
ID:389777 发表于 2019-1-11 12:30 | 显示全部楼层
大拿 发表于 2017-11-28 13:07
LCD.c(495): error C141: syntax error near 'TF0_VECTOR', expected 'const'
LCD.c(495): error C132: 'T ...

我的也是一样
回复

使用道具 举报

ID:389777 发表于 2019-1-11 19:15 | 显示全部楼层

       这个是没有问题的                                         
  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. #include    <reg52.h>
  18. #include    <intrins.h>               
  19. #define     uchar        unsigned char
  20. #define     uint         unsigned int
  21. #define     time_count   0x3cb0
  22. #define     close        1
  23. #define     open         0

  24. /*============ 状态控制及温感器总线定义 ==============*/

  25.   sbit b20_io=P3^7;               // DS18B20总线         
  26.   sbit pw_oc=P3^2;                // 密码锁开启控制(黄灯)
  27.   sbit buzzer=P3^3;               // 蜂鸣器
  28.   sbit lcd_bl=P2^0;               // 背光控制口
  29.   sbit als_th=P2^1;               // 上限温度警报(红灯)
  30.   sbit als_tl=P2^2;               // 下限温度警报(绿灯)
  31.   #define  keyboard   P1          // 键盘数据口


  32. /*================= ST7920LCD 定义 ===================*/

  33. #define     comm 0                // lcd指令
  34. #define     dat 1                 // lcd数据
  35. //sbit lcd_rst=P2^3;             // lcd复位
  36. sbit lcd_e=P2^7;                // lcd使能
  37. sbit lcd_rw=P2^5;               // lcd读写
  38. sbit lcd_rs=P2^6;               // lcd数据命令
  39. sbit busy=P0^7;                 // 忙碌位
  40. #define   lcd_data  P0                       // lcd(8bit)数据传输

  41.   
  42. /*=============== DS1302 寄存器地址定义 ===============*/

  43. sbit d02_rst=P3^5;                // DS1302使能
  44. sbit d02_data=P3^4;                // DS1302数据线
  45. sbit d02_sclk=P3^6;               // DS1302脉冲
  46. #define     d02_wrc      0x8e                // 1302读写RAM控制(1允许 0禁止)
  47. #define     d02_year         0x8c                // 年
  48. #define     d02_weeks         0x8a                // 星期
  49. #define     d02_month         0x88                // 月
  50. #define     d02_day                 0x86                // 日
  51. #define     d02_hour         0x84                // 时
  52. #define     d02_minute         0x82                // 分
  53. #define     d02_second         0x80                // 秒
  54. #define     d02_signs         0xc0                // 系统状态(记录设置标记)
  55. #define     d02_passw         0xc2                // 密码寄存器首位(有3位下位地址加2,初始值为:741456)
  56. #define     d02_alm           0xc8                // 闹铃时间小时位(下位为分钟位加2)
  57. #define     d02_temp         0xcc                // 温度上限警报(有两位下位位下限加2)
  58. #define     d02_initsi   0xd4                // 1302初始化标记(为0xb4时,说明已经初始化)
  59. #define     ret_ds1302()    d02_rst=0;d02_sclk=0;d02_rst=1        // 1302读写复位
  60. #define     end_ds1302()    d02_sclk=1;d02_rst=0                        // 1302读写结束



  61. /*================================= 全局变量定义 ==================================*/


  62. typedef        struct                        // 定义时间类型
  63. {
  64.   uchar        hour;
  65.   uchar        minute;
  66.   uchar        second;
  67. }time;

  68. typedef        struct                        // 定义日期类型
  69. {
  70.   uchar        year;
  71.   uchar        month;
  72.   uchar        day;
  73.   uchar        week;
  74. }date;

  75. typedef union                     // 定义温度类型
  76. {
  77.   int temp_data;
  78.   uchar t_data[2];
  79. }trdata;

  80. trdata  bdata  temp;             // 温度警报值暂存        
  81. date    idata  today={'8',1,1,1};         // 日期暂存
  82. time    idata  now={0x12,0,0} , save_time={0x12,0,0};
  83.               // 时间暂存(now是读出时间暂存 save_time上一时间暂存)
  84. uchar   idata  time_tick=20,time_tick1=20,alarm_time[2],als_temp[2],
  85.               // T0中断数,     T1中断数,     闹铃时间,   警报温度
  86.                bl_delay=15,temp_delay=5,opera[2][12],resu[12],
  87.                           // 背光时间,  温度更新时间, 计算器数据寄存, 结果寄存
  88.                            i,j,save1,temp_min=0;
  89.                            // 计算器i/j下标,中间暂存,温度更新(分)



  90. uchar  bdata   signs=0;                 // 系统标记寄存器
  91.   sbit bl1=signs^7;                  // bl1,bl0背光选择位(00 延时,01 常开,10 关闭)
  92.   sbit bl0=signs^6;                        
  93.   sbit di1=signs^5;                         // di1,di0显示模式(00模式1,01模式2,10模式3)
  94.   sbit di0=signs^4;                        
  95.   sbit meu=signs^3;                         // 菜单显示方式(0 图片,1 文字)
  96.   sbit keb=signs^2;                         // 键盘锁(0 无锁,1加锁)
  97.   sbit alm=signs^1;                         // 闹钟启动位(0 关闭,1开启)
  98.   sbit als=signs^0;                         // 报警启动位(0 启动,1关闭)



  99. uint   bdata   run_signs=0;     // 运行标记寄存器
  100.   sbit ds18b20=run_signs^0;                // 温感器存在标记(0不存在,1存在)
  101.   sbit temp_pn=run_signs^1;                // 温度正负号标记(0正,1负)
  102.   sbit temprun=run_signs^2;                // 温感器运行标记(0否,1启动)
  103.   sbit nba_tim=run_signs^3;           // 篮球计时器标记(0关闭,1启动)
  104.   sbit adju_si=run_signs^4;                // 数字更改连续标记(1连续)
  105.   sbit cal_del=run_signs^5;     // 计算器显示点标记(0没有显示)
  106.   sbit cal_run=run_signs^6;            // 计算完毕标记(1有效)
  107.   sbit oth_run=run_signs^7;     // 其他标记
  108.   sbit alm_run=run_signs^8;     // 闹钟时间到达标记(1有效)
  109.   sbit dis_sig=run_signs^9;     // 显示时间标记(1有效)
  110.   sbit lock_op=run_signs^10;    // 关锁时间到标记(1有效)
  111.   sbit b20time=run_signs^11;    // 温感器重新读温度标记(1有效)
  112.   sbit t0_isr =run_signs^12;    // TO中断标记(1有效(1s)
  113.   sbit thl_als=run_signs^13;        // 温度警报标记
  114.   sbit init_d2=run_signs^14;        // 模式2初始显示
  115.   sbit buzstop=run_signs^15;        // 蜂鸣器停止标记




  116. /*================================= 字体显示代码 ==================================*/

  117. uchar code weeks[7][2]={"一","二","三","四","五","六","日"}; // 星期                                //图片中文
  118. uchar code menu_cn[6][8]={"调    整","工    具","设    置","保    密","版    本","退    出"};
  119. uchar code menu_cn_2[6][6]={"调  整","工  具","设  置","保  密","版  本","退  出"};// 菜单文字
  120. uchar code selected[2][16]={{"进入【      】\x04 "},{"设置【    】\x10 \x04 "}}; // 选框
  121. uchar code secrets_menu[4][6]={"开  锁","更  改","初始化","退  出"};           // 保密菜单中文
  122. uchar code tool_menu[5][6]={"计算器","温度计","闹  铃","篮球器","退  出"};           // 工具菜单中文
  123. uchar code char_num[10]={"0123456789"};         // 数字显示代码                                                         // 每月天数
  124. uchar code dayofmonth[12]={0x31,0x28,0x31,0x30,0x31,0x30,0x31,0x31,0x30,0x31,0x30,0x31};
  125. uchar code key_code[]={0xD7,0x7E,0x7D,0x7B,0xBE,0xBD,0xBB,0xDE,0xDD,0xDB,0xB7,0x77,0xEE,0xED,0xEB,0xE7};
  126. uchar code ksp[4]={0x7F,0xBF,0xDF,0xEF};         // 按键扫描代码
  127. uchar code tool_cal[4][2]={"+ ","- ","* ","/ "}; // 运算符号
  128. uchar code alm_sign[2][2]={"关","开"};                         // 闹铃开关
  129. uchar code set_bl_dm[2][3][4]={{"30秒","常开","关闭"},{"模01","模02","模03"}};
  130. uchar code set_mka[3][2][4]={{"图片","文字"},{"解锁","加锁"},{"开启","关闭"}};
  131. uchar code nba_oppo[8][2]={"红","白","蓝","绿","紫","灰","黄","黑"};
  132. uchar code set_menu[6][4]={"背光","显示","菜单","键盘","警报","退出"};


  133. uchar code version[10][14]={   // 版本信息
  134.                             {"清远职业技术学"},
  135.                                                         {"  信息科技学院"},
  136.                                                 {"08届毕业设计  "},
  137.                                                 {"  —05电子02班"},
  138.                                         {"作者:李锦华  "},
  139.                                                 {"指导:李祖明  "},
  140.                                                 {"版本:LIJH-V1.0"},
  141.                                                 {"    2008/06/19"},
  142.                                                 {"谢谢你的使用!"},
  143.                                                 {"         (ok)\x10"}};


  144. uchar code timer_tips[12][16]={ // 篮球器使用说明
  145.                             {"使用方法:      "},
  146.                                                         {"  (+)(-)与(*)(/)"},
  147.                                                         {"分别是两方的分数"},
  148.                                                         {"加与减,(7)键回退"},
  149.                                                         {"一秒,(8)键24秒复"},
  150.                                                         {"位,(9)键暂停与开"},
  151.                                                         {"始;暂停状态下:"},
  152.                                                         {"按两次(OK)键可返"},
  153.                                                         {"回时钟模式-2界面"},
  154.                                                         {",(OK)键返回程序"},
  155.                                                         {"界面,(./S)键两次"},
  156.                                                         {"退出程序.      \x1f"}};



  157. /*================================= 操作导航代码 ==================================*/


  158. typedef struct                        // 定义主菜单操作索引
  159. {
  160.   uchar shaft_num;
  161.   uchar left_num;
  162.   uchar right_num;
  163. }menu_index;

  164. typedef struct                        // 定义导航更改索引
  165. {
  166.   uchar lnum;
  167.   uchar rnum;
  168. }index;

  169. menu_index code index_m[6]={{3,5,1},{4,0,2},{5,1,3},{0,2,4},{1,3,5},{2,4,0}}; // 菜单导航
  170. index code index_t[6]={{4,1},{0,2},{1,3},{2,4},{3,0}};       // 工具导航
  171. index code index_p[5]={{3,1},{0,2},{1,3},{2,0}};             // 保密导航
  172. index code index_s[6]={{5,1},{0,2},{1,3},{2,4},{3,5},{4,0}}; // 设置导航
  173. index code index_a[7]={{0x81,0x91},{0x83,0x91},{0x85,0x91},{0x89,0x81},
  174.                                 {0x8b,0x81},{0x8d,0x81},{0x8f,0x91}};       // 调整下的坐标
  175. index code index_temp_set[3]={{0x8b,0x81},{0x8b,0x91},{0x8f,0x91}}; // 温度设定下的坐标
  176. index code index_alm[3]={{0x8c,0x81},{0x8e,0x81},{0x8f,0x91}};            // 闹铃更改坐标        
  177. index code index_cal[3]={{0x86,0x90},{0x8e,0x80},{0x8e,0x90}};            // 计算器操作坐标
  178. uchar code index_nba[4]={0x93,0x97,0x8b,0x8f};                                            // 篮球器设置导航





  179. /*========================== 菜单图片(宽度x高度=32*24)=============================*/

  180. uchar code menu_pic[6][96]={
  181.         {// 调整
  182.          0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x00,0x00,0x02,
  183.          0x40,0x00,0x00,0x82,0x47,0xFF,0xE1,0xC2,0x47,0xFF,0xF3,0xE2,0x47,0x38,0x68,0x02,
  184.          0x46,0xDF,0x68,0x82,0x46,0xDF,0x69,0xC2,0x46,0xDE,0xE8,0x82,0x46,0xDD,0xE8,0x02,
  185.          0x46,0xDD,0xE8,0x02,0x47,0x3D,0xE8,0x02,0x47,0xFF,0xE8,0x02,0x47,0xFF,0xE9,0xC2,
  186.          0x42,0x00,0x18,0x02,0x41,0xFF,0xF3,0xE2,0x40,0x00,0x01,0xC2,0x40,0x00,0x00,0x82,
  187.          0x40,0x00,0x00,0x02,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
  188.         
  189.         {// 工具                                       
  190.          0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x00,0x03,0x82,
  191.          0x41,0xF0,0x07,0xC2,0x43,0xFF,0xCF,0xE2,0x47,0x3F,0xFE,0x02,0x47,0x3F,0xFE,0x02,
  192.          0x43,0xFF,0xCF,0xE2,0x41,0xF0,0x0F,0xC2,0x40,0x00,0x03,0x82,0x40,0x00,0x00,0x02,
  193.          0x40,0x00,0x03,0xC2,0x40,0x00,0x03,0xC2,0x41,0x80,0x01,0x82,0x43,0xFF,0xF3,0xC2,
  194.          0x47,0xFF,0xFF,0xE2,0x47,0xFF,0xFF,0xE2,0x43,0xFF,0xF3,0xC2,0x41,0x80,0x01,0x82,
  195.          0x40,0x00,0x01,0x82,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
  196.         
  197.         {// 设置
  198.          0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x43,0x18,0x00,0x02,
  199.          0x44,0xA4,0x0E,0x02,0x44,0xA4,0x1F,0x02,0x43,0x24,0x3F,0x02,0x40,0x00,0x7F,0x02,
  200.          0x40,0xF0,0xFC,0x02,0x43,0xF9,0xF0,0x02,0x43,0x03,0xE0,0x02,0x46,0x77,0x80,0x02,
  201.          0x46,0x7F,0x00,0x02,0x46,0x7E,0x00,0x02,0x46,0x7C,0x00,0x02,0x47,0x3D,0x00,0x02,
  202.          0x43,0x1D,0x81,0x22,0x43,0x81,0xB2,0x42,0x41,0xC3,0x4F,0xE2,0x40,0xFE,0x4A,0x42,
  203.          0x40,0x3C,0x32,0x42,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
  204.         
  205.         {// 保密
  206.          0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0xFC,0x03,0x02,
  207.          0x41,0xFE,0x1F,0x02,0x43,0x87,0x03,0x82,0x43,0x03,0x03,0x02,0x43,0x03,0x03,0x02,
  208.          0x43,0x03,0x0F,0x02,0x43,0x03,0x03,0x02,0x43,0x03,0x03,0x02,0x47,0xFF,0x83,0x02,
  209.          0x47,0xFF,0x83,0x02,0x47,0xCF,0x83,0x02,0x47,0x87,0x83,0x02,0x47,0xCF,0x83,0x02,
  210.          0x47,0xCF,0x87,0x82,0x47,0xCF,0x8F,0xC2,0x47,0xCF,0x9C,0xE2,0x47,0xFF,0x8F,0xC2,
  211.          0x43,0xFF,0x07,0x82,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
  212.         
  213.         {// 版本
  214.          0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x00,0x00,0x02,
  215.          0x40,0x0F,0x00,0x62,0x40,0x1D,0x80,0xF2,0x40,0x38,0x41,0xF2,0x40,0x70,0x23,0xE2,
  216.          0x40,0xE2,0x17,0xC2,0x41,0xE4,0x4F,0x82,0x41,0xF0,0x9F,0x02,0x41,0x59,0x16,0x02,
  217.          0x42,0x4C,0x1D,0x02,0x42,0x46,0x20,0x82,0x42,0x47,0x00,0x42,0x44,0x43,0x80,0xC2,
  218.          0x44,0x44,0xC1,0xC2,0x44,0xC8,0x63,0x82,0x45,0x50,0x37,0x02,0x46,0x60,0x1E,0x02,
  219.          0x40,0x40,0x0C,0x02,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00},
  220.         
  221.         {// 退出
  222.          0x00,0x00,0x00,0x00,0x7F,0xFF,0xFF,0xFE,0x40,0x00,0x00,0x02,0x40,0x40,0xFF,0xE2,
  223.          0x40,0x60,0x80,0x62,0x43,0xF0,0x80,0xA2,0x43,0xF0,0x81,0x22,0x40,0x60,0x82,0x22,
  224.          0x40,0x40,0x84,0x22,0x40,0x00,0x88,0x22,0x40,0x00,0x88,0x22,0x47,0xFF,0xF8,0x22,
  225.          0x47,0xFF,0xF8,0x22,0x46,0x2A,0x2A,0x22,0x46,0xE3,0x78,0x22,0x46,0x77,0x78,0x22,
  226.          0x46,0xE3,0x78,0x62,0x46,0x2A,0x38,0x82,0x47,0xFF,0xF9,0x02,0x47,0xFF,0xFA,0x02,
  227.          0x40,0x00,0x0C,0x02,0x40,0x00,0x00,0x02,0x7F,0xFF,0xFF,0xFE,0x00,0x00,0x00,0x00,}};




  228. /*================ 显示模式2数字及温度符号图片(宽度x高度=16*32)=====================*/

  229. uchar code mode_2num[11][64]={
  230.         {// 图片数字0
  231.          0x00,0x00,0x3F,0xFC,0x5F,0xFA,0x6F,0xF6,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
  232.          0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x60,0x06,0x40,0x02,0x00,0x00,
  233.          0x40,0x02,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
  234.          0x70,0x0E,0x70,0x0E,0x70,0x0E,0x6F,0xF6,0x5F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
  235.         
  236.         {// 图片数字1
  237.          0x00,0x00,0x00,0x20,0x00,0x60,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,
  238.      0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0x60,0x00,0x20,0x00,0x00,0x00,0x20,
  239.          0x00,0x60,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0xE0,
  240.          0x00,0xE0,0x00,0xE0,0x00,0xE0,0x00,0x60,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00},
  241.    
  242.         {// 图片数字2
  243.          0x00,0x00,0x3F,0xFC,0x1F,0xFA,0x0F,0xF6,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  244.          0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x1F,0xFA,0x3F,0xFC,
  245.          0x5F,0xF8,0x60,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,
  246.          0x70,0x00,0x70,0x00,0x70,0x00,0x6F,0xF8,0x5F,0xFC,0x3F,0xFE,0x00,0x00,0x00,0x00},
  247.         
  248.         {// 图片数字3
  249.          0x00,0x00,0x7F,0xFC,0x3F,0xFA,0x1F,0xF6,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  250.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x1F,0xFA,0x3F,0xFC,
  251.      0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  252.      0x00,0x0E,0x00,0x0E,0x00,0x0E,0x1F,0xF6,0x3F,0xFA,0x7F,0xFC,0x00,0x00,0x00,0x00},
  253.         
  254.         {// 图片数字4
  255.          0x00,0x00,0x40,0x02,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
  256.           0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x60,0x06,0x5F,0xFA,0x3F,0xFC,
  257.          0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  258.          0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x00,0x02,0x00,0x00,0x00,0x00},
  259.         
  260.         {// 图片数字5
  261.          0x00,0x00,0x3F,0xFC,0x5F,0xF8,0x6F,0xF0,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,
  262.          0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x60,0x00,0x5F,0xF8,0x3F,0xFC,
  263.          0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  264.          0x00,0x0E,0x00,0x0E,0x00,0x0E,0x0F,0xF6,0x1F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
  265.          
  266.         {// 图片数字6
  267.          0x00,0x00,0x3F,0xFC,0x5F,0xF8,0x6F,0xF0,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,
  268.          0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x70,0x00,0x60,0x00,0x5F,0xF8,0x3F,0xFC,
  269.          0x5F,0xFA,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
  270.          0x70,0x0E,0x70,0x0E,0x70,0x0E,0x6F,0xF6,0x5F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
  271.         
  272.         {// 图片数字7
  273.          0x00,0x00,0x7F,0xFC,0x3F,0xFA,0x1F,0xF6,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  274.          0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x00,0x02,0x00,0x00,
  275.          0x00,0x02,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  276.          0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x06,0x00,0x02,0x00,0x00,0x00,0x00},
  277.         
  278.         {// 图片数字8
  279.          0x00,0x00,0x3F,0xFC,0x5F,0xFA,0x6F,0xF6,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
  280.          0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x60,0x06,0x5F,0xFA,0x3F,0xFC,
  281.          0x5F,0xFA,0x60,0x06,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,0x70,0x0E,
  282.          0x70,0x0E,0x70,0x0E,0x70,0x0E,0x6F,0xF6,0x5F,0xFA,0x3F,0xFC,0x00,0x00,0x00,0x00},
  283.         
  284.         {// 图片数字9
  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,0x5F,0xFA,0x3F,0xFC,
  287.          0x1F,0xFA,0x00,0x06,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,0x00,0x0E,
  288.          0x00,0x0E,0x00,0x0E,0x00,0x0E,0x1F,0xF6,0x3F,0xFA,0x7F,0xFC,0x00,0x00,0x00,0x00},
  289.         
  290.         {// 温度符号
  291.      0x00,0x00,0x00,0x00,0x70,0xE0,0x53,0xF0,0x77,0xFA,0x0E,0x0E,0x0C,0x06,0x18,0x06,
  292.      0x18,0x02,0x38,0x02,0x30,0x00,0x30,0x00,0x70,0x00,0x60,0x00,0x60,0x00,0x60,0x00,
  293.      0x60,0x00,0x60,0x00,0x70,0x00,0x30,0x00,0x30,0x00,0x38,0x00,0x18,0x02,0x18,0x02,
  294.      0x0C,0x06,0x0E,0x06,0x07,0x0E,0x03,0xFA,0x00,0xF0,0x00,0x60,0x00,0x00,0x00,0x00}};





  295. /*===================== 显示模式3数字图片(宽度x高度=24*32)=========================*/

  296. uchar code mode_3num[10][96]={
  297.         {// 图片数字0
  298.          0x00,0x7E,0x00,0x01,0xE7,0x80,0x03,0xC3,0xC0,0x07,0x81,0xE0,0x0F,0x80,0xF0,0x0F,
  299.          0x00,0xF0,0x1F,0x00,0xF8,0x1E,0x00,0xF8,0x3E,0x00,0x78,0x3E,0x00,0x7C,0x3E,0x00,
  300.          0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,
  301.          0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,
  302.          0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x78,0x1E,0x00,0xF8,0x1F,0x00,0xF8,0x0F,0x00,
  303.          0xF0,0x0F,0x81,0xF0,0x07,0x81,0xE0,0x03,0xC3,0xC0,0x01,0xE7,0x80,0x00,0x7E,0x00},

  304.         {// 图片数字1
  305.          0x00,0x0C,0x00,0x00,0x1C,0x00,0x00,0x7C,0x00,0x07,0xFC,0x00,0x00,0x3C,0x00,0x00,
  306.          0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,
  307.          0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,
  308.          0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,
  309.          0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,
  310.          0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3E,0x00,0x00,0x7F,0x00,0x07,0xFF,0xF0},
  311.                            
  312.         {// 图片数字2
  313.          0x00,0xFF,0x00,0x03,0xC7,0xC0,0x07,0x01,0xE0,0x0E,0x00,0xF0,0x1E,0x00,0xF8,0x1E,
  314.          0x00,0xF8,0x3E,0x00,0x78,0x3E,0x00,0x78,0x3F,0x00,0x78,0x3F,0x00,0x78,0x1F,0x00,
  315.      0xF8,0x00,0x00,0xF8,0x00,0x00,0xF0,0x00,0x01,0xF0,0x00,0x03,0xE0,0x00,0x03,0xC0,
  316.          0x00,0x07,0x80,0x00,0x0F,0x00,0x00,0x1E,0x00,0x00,0x3C,0x00,0x00,0x78,0x00,0x00,
  317.          0xF0,0x00,0x01,0xE0,0x00,0x03,0xC0,0x00,0x07,0x80,0x1C,0x07,0x00,0x1C,0x0E,0x00,
  318.          0x38,0x1C,0x00,0x38,0x3C,0x00,0x78,0x3F,0xFF,0xF8,0x3F,0xFF,0xF8,0x3F,0xFF,0xF8},

  319.         {// 图片数字3
  320.          0x00,0xFE,0x00,0x07,0x87,0x80,0x0F,0x03,0xC0,0x1E,0x01,0xE0,0x1E,0x01,0xF0,0x1E,
  321.          0x01,0xF0,0x1F,0x00,0xF0,0x1F,0x00,0xF0,0x1E,0x00,0xF0,0x00,0x00,0xF0,0x00,0x01,
  322.          0xF0,0x00,0x01,0xF0,0x00,0x03,0xE0,0x00,0x03,0xC0,0x00,0x0F,0x00,0x00,0xFE,0x00,
  323.          0x00,0x07,0x80,0x00,0x01,0xE0,0x00,0x00,0xF0,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,
  324.          0x00,0x78,0x00,0x00,0x7C,0x1E,0x00,0x7C,0x3F,0x00,0x7C,0x3F,0x00,0x7C,0x3F,0x00,
  325.          0x78,0x3E,0x00,0xF8,0x1E,0x00,0xF0,0x0F,0x01,0xE0,0x07,0x87,0xC0,0x01,0xFF,0x00},

  326.         {// 图片数字4
  327.          0x00,0x03,0xC0,0x00,0x03,0xC0,0x00,0x07,0xC0,0x00,0x0F,0xC0,0x00,0x0F,0xC0,0x00,
  328.          0x1F,0xC0,0x00,0x3F,0xC0,0x00,0x3F,0xC0,0x00,0x77,0xC0,0x00,0x77,0xC0,0x00,0xE7,
  329.          0xC0,0x01,0xC7,0xC0,0x01,0xC7,0xC0,0x03,0x87,0xC0,0x07,0x07,0xC0,0x07,0x07,0xC0,
  330.          0x0E,0x07,0xC0,0x1E,0x07,0xC0,0x1C,0x07,0xC0,0x38,0x07,0xC0,0x38,0x07,0xC0,0x7F,
  331.          0xFF,0xFE,0x7F,0xFF,0xFE,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,
  332.          0xC0,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,0xC0,0x00,0x07,0xE0,0x00,0x7F,0xFE},

  333.         {// 图片数字5
  334.          0x0F,0xFF,0xF8,0x0F,0xFF,0xF8,0x0F,0xFF,0xF8,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,
  335.          0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,0x00,0x0E,0x00,
  336.          0x00,0x0E,0x7F,0x00,0x0D,0xFF,0xC0,0x0F,0xC3,0xE0,0x1F,0x01,0xF0,0x1E,0x00,0xF8,
  337.          0x1E,0x00,0xF8,0x00,0x00,0x78,0x00,0x00,0x7C,0x00,0x00,0x7C,0x00,0x00,0x7C,0x00,
  338.          0x00,0x7C,0x1E,0x00,0x7C,0x3F,0x00,0x7C,0x3F,0x00,0x78,0x3F,0x00,0x78,0x3E,0x00,
  339.          0xF8,0x1E,0x00,0xF0,0x1E,0x01,0xF0,0x0E,0x01,0xE0,0x07,0x87,0xC0,0x00,0xFF,0x00},

  340.         {// 图片数字6
  341.          0x00,0x3F,0xC0,0x00,0xF1,0xE0,0x03,0xC1,0xF0,0x07,0x81,0xF8,0x07,0x01,0xF8,0x0F,
  342.          0x00,0xF0,0x1F,0x00,0x00,0x1E,0x00,0x00,0x1E,0x00,0x00,0x3E,0x00,0x00,0x3E,0x00,
  343.          0x00,0x3E,0x00,0x00,0x3E,0x3F,0x80,0x3E,0xFF,0xE0,0x3F,0xE3,0xF0,0x3F,0x80,0xF8,
  344.          0x3F,0x00,0xF8,0x3F,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x7C,0x3E,0x00,0x3C,0x3E,
  345.          0x00,0x3C,0x3E,0x00,0x3C,0x3E,0x00,0x3C,0x3E,0x00,0x7C,0x1E,0x00,0x7C,0x1F,0x00,
  346.          0x78,0x0F,0x00,0x78,0x0F,0x80,0xF0,0x07,0xC0,0xE0,0x03,0xE3,0xC0,0x00,0xFF,0x00},

  347.         {// 图片数字7
  348.          0x1F,0xFF,0xFC,0x1F,0xFF,0xFC,0x1F,0xFF,0xF8,0x1F,0x00,0x38,0x1C,0x00,0x70,0x1C,
  349.          0x00,0xE0,0x38,0x00,0xE0,0x38,0x01,0xC0,0x00,0x01,0xC0,0x00,0x03,0x80,0x00,0x03,
  350.          0x80,0x00,0x07,0x80,0x00,0x07,0x00,0x00,0x0F,0x00,0x00,0x0E,0x00,0x00,0x1E,0x00,
  351.          0x00,0x1E,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x3C,0x00,0x00,0x7C,0x00,0x00,
  352.          0x78,0x00,0x00,0x78,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,
  353.          0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0x78,0x00},

  354.         {// 图片数字8
  355.          0x00,0xFF,0x00,0x07,0xC3,0xC0,0x0F,0x00,0xE0,0x1E,0x00,0xF0,0x1E,0x00,0x78,0x3C,
  356.          0x00,0x78,0x3C,0x00,0x78,0x3C,0x00,0x7C,0x3E,0x00,0x78,0x3E,0x00,0x78,0x1F,0x00,
  357.          0x78,0x1F,0x80,0xF0,0x0F,0xE1,0xE0,0x07,0xFB,0xC0,0x01,0xFF,0x80,0x01,0xFF,0x80,
  358.          0x07,0xBF,0xC0,0x0F,0x0F,0xE0,0x1E,0x03,0xF0,0x3E,0x01,0xF8,0x3C,0x00,0xF8,0x3C,
  359.          0x00,0x7C,0x7C,0x00,0x7C,0x78,0x00,0x3C,0x78,0x00,0x3C,0x7C,0x00,0x3C,0x3C,0x00,
  360.          0x78,0x3C,0x00,0x78,0x1E,0x00,0x70,0x0F,0x00,0xE0,0x07,0xC3,0xC0,0x01,0xFF,0x00},

  361.         {// 图片数字9
  362.          0x01,0xFE,0x00,0x07,0xC7,0x80,0x0F,0x01,0xE0,0x1E,0x01,0xE0,0x1E,0x00,0xF0,0x3E,
  363.          0x00,0xF8,0x3C,0x00,0x78,0x3C,0x00,0x78,0x7C,0x00,0x7C,0x7C,0x00,0x7C,0x7C,0x00,
  364.          0x7C,0x7C,0x00,0x7C,0x7C,0x00,0x7C,0x3C,0x00,0xFC,0x3E,0x00,0xFC,0x3E,0x01,0xFC,
  365.      0x1F,0x03,0xFC,0x1F,0x8F,0xFC,0x0F,0xFF,0x7C,0x03,0xFC,0x7C,0x00,0x00,0x7C,0x00,
  366.      0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF8,0x00,0x00,0xF0,0x00,0x01,0xF0,0x0F,0x01,
  367.          0xE0,0x1F,0x01,0xE0,0x1F,0x03,0xC0,0x1F,0x07,0x80,0x0F,0x9F,0x00,0x03,0xFC,0x00}};




  368. /*========================== 标记及点图片(宽度x高度=16*16)===========================*/


  369. uchar code running[7][32]={
  370.      {// 警报标记16*16
  371.           0x00,0x00,0x00,0x39,0x00,0x7B,0x00,0xFE,0x01,0xDC,0x0F,0x98,0x0F,0x18,0x0C,0x1F,
  372.       0x0C,0x1F,0x0F,0x18,0x0F,0x98,0x01,0xDC,0x00,0xFE,0x00,0x7B,0x00,0x39,0x00,0x00,},
  373.          {// 闹铃开启标记16*16
  374.           0x00,0x00,0x00,0x40,0x00,0xE0,0x01,0xB0,0x01,0xB0,0x03,0x18,0x03,0x18,0x06,0x0C,
  375.       0x0C,0x06,0x0C,0xE6,0x1B,0x1B,0x0C,0x06,0x06,0x0C,0x03,0xF8,0x00,0xE0,0x00,0x00},
  376.          {// 键盘锁标记16*16
  377.       0x00,0x00,0x01,0xF8,0x03,0xFC,0x03,0x0C,0x03,0x0C,0x03,0x0C,0x03,0xFC,0x06,0x96,
  378.       0x0E,0xA7,0x0E,0xC7,0x0E,0xA7,0x0E,0x97,0x07,0xFE,0x03,0xFC,0x01,0xF8,0x00,0x00,},
  379.          {// 温度计标记16*16
  380.           0x00,0x00,0x1F,0xF8,0x1F,0xF8,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80,
  381.       0x01,0x90,0x01,0x98,0x01,0x9C,0x01,0x9E,0x01,0x9C,0x00,0x18,0x00,0x10,0x00,0x00},
  382.          {// 模式3点16*16
  383.           0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,
  384.       0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
  385.          {// 模式2点16*16
  386.           0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xC0,0x03,0xC0,0x03,0xC0,0x03,0xC0,
  387.       0x03,0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},         
  388.          {// 篮球器运行标记16*16
  389.           0x00,0x00,0x00,0x00,0x00,0x00,0x1F,0xF8,0x1F,0xF8,0x01,0x80,0x01,0x80,0x01,0x90,
  390.       0x01,0x98,0x01,0x9C,0x01,0x9E,0x01,0x9C,0x01,0x98,0x01,0x90,0x00,0x00,0x00,0x00}};


  391. /*========================== 菜单按钮图片(宽度x高度=16*8)============================*/

  392. uchar code menu_key[]=
  393.          {//菜单按钮
  394.           0x7F,0xFE,0x81,0x81,0x83,0xC1,0x87,0xE1,0x8F,0xF1,0x9F,0xF9,0x80,0x01,0x7F,0xFE};





  395. /*=====================================================================================
  396. 函数名称:定时器中断处理与初始化,延时
  397. 功能描述:时钟更新、篮球器计时
  398. 全局变量:time_tick、time_tick1、resu[2]、resu[3]、resu[4]、temp_delay、temp_min
  399. 参数说明:无
  400. 返回说明:t0_isr(中断标记)、b20time(温度更新标记)
  401. 设 计 人:LIJH
  402. 版    本:1.0
  403. 说    明:
  404. ======================================================================================*/


  405. /*延时(一次10个机器周期不等) 参数格式:延时数*/
  406. void delay(unsigned int det)
  407. {
  408.   while(det--);
  409. }



  410. /*1s延时*/
  411. void delay_pw()
  412. {
  413.   delay(60000);
  414.   delay(60000);
  415. }


  416. /*6个周期  6us */
  417. void  delay_b20(uchar n)
  418. {  
  419.   while(n--);
  420. }



  421. /*主时钟中断处理*/
  422. void time0_isr(void)interrupt 1  using 0         
  423. {
  424.   TR0=0;
  425.   TL0=(time_count&0x00FF);
  426.   TH0=(time_count>>8);
  427.   TR0=1;
  428.   if(--time_tick)
  429.    return;
  430.   time_tick=20;
  431.   t0_isr=1;
  432.   if(nba_tim&!oth_run)           // 当在篮球器界面时 nba_tim==1、oth_run==0
  433.   {
  434.     if(resu[3]==0)
  435.         {
  436.           resu[3]=59;
  437.           if(resu[2]>0)        resu[2]--;
  438.         }
  439.         else resu[3]--;
  440.         if(resu[2]==0&resu[3]==0)  // 比赛时间到后停止
  441.         {
  442.           TR0=0;TR1=0;EA=0;
  443.         }
  444.         return;
  445.   }
  446.   if((++temp_min)==60)          // 实现温度的更新
  447.   {
  448.     temp_min=0;
  449.     temp_delay--;
  450.         if(temp_delay==0)
  451.     {
  452.           b20time=1;temp_delay=5;
  453.         }
  454.   }        
  455. }
  456.   

  457. /*24时钟中断处理*/
  458. void time1_isr(void) interrupt 3 using 1
  459. {
  460.   TR1=0;
  461.   TL1=(time_count&0x00FF);
  462.   TH1=(time_count>>8);
  463.   TR1=1;
  464.   if(--time_tick1) return;
  465.   time_tick1=20;
  466.   if(resu[4]>0)resu[4]--;          //  篮球器24秒中断
  467.   t0_isr=1;
  468.   if(resu[4]==0)
  469.   { TR0=0;TR1=0;EA=0;}
  470. }


  471. /*定时器初始化*/
  472. void time_init()                        
  473. {
  474.   EA=0;
  475.   TR0=0;
  476.   TR1=0;
  477.   TMOD=0x11;
  478.   TL0=(time_count&0x00FF);
  479.   TH0=(time_count>>8);
  480.   TL1=(time_count&0x00FF);
  481.   TH1=(time_count>>8);
  482.   IE=0;
  483.   ET0=1;
  484.   ET1=1;
  485. }



  486. /*=====================================================================================
  487. 函数名称:LCD驱动
  488. 功能描述:基本驱动(写1个字节、清屏、初始化)
  489. 全局变量:无
  490. 参数说明:dat_comm(0:命令 1:数据),content(数值)
  491. 返回说明:无返回值
  492. 设 计 人:LIJH
  493. 版    本:1.0
  494. 说    明:
  495. ======================================================================================*/


  496. /*检查忙碌位*/
  497. void chk_busy (void)
  498. {
  499.   lcd_data=0xff;
  500.   lcd_rs = 0;    // 命令
  501.   lcd_rw = 1;         // 读
  502.   lcd_e = 1;
  503.   while(busy==1);
  504.   lcd_e = 0;
  505. }


  506. /*写LCD 参数格式:0:命令,1:数值 ,数据*/
  507. void wr_lcd (uchar dat_comm,uchar content)
  508. {
  509.   chk_busy ();
  510.   lcd_rs=dat_comm;
  511.   lcd_rw = 0;         // 写
  512.   lcd_data=content;   // 输出数据或命令
  513.   lcd_e=1;            
  514.   lcd_e=0;
  515. }


  516. /*清绘图*/
  517. void clrgdram(void)
  518. {
  519.   uchar i,j;
  520.   for(j=0;j<32;j++)
  521.   {
  522.     wr_lcd(comm,0x34);
  523.     wr_lcd(comm,0x80+j);
  524.     wr_lcd(comm,0x80);
  525.     wr_lcd(comm,0x30);
  526.     for(i=0;i<32;i++)
  527.       wr_lcd(dat,0x00);  // 写入0x00
  528.    }
  529.   wr_lcd(comm,0x36);
  530. }


  531. /*清除显示*/
  532. void clear_dis(void)
  533. {
  534.   wr_lcd(comm,0x30);
  535.   wr_lcd(comm,0x01);  // 清屏,地址指针指向00H
  536.   clrgdram();                  // 请绘图RAM
  537. }



  538. /*开机LCD初始化*/
  539. void init_lcd (void)
  540. {
  541.   //lcd_rst=1;
  542.   wr_lcd(comm,0x30);  // 30---基本指令动作  
  543.   wr_lcd(comm,0x06);  // 光标的移动方向
  544.   wr_lcd(comm,0x0c);  // 开显示,关游标
  545.   clear_dis();
  546. }





  547. /*=====================================================================================
  548. 函数名称:DS1302驱动
  549. 功能描述:基本驱动(读写数据、读写日期,时间、初始化)
  550. 全局变量:无
  551. 参数说明:w_adder(写地址),r_adder(读地址),w_data(写入数据)
  552. 返回说明:返回读取的数据
  553. 设 计 人:LIJH
  554. 版    本:1.0
  555. 说    明:上升沿写入数值,下降沿读出数值,没用设立后背电池充电
  556. ======================================================================================*/


  557. /*向1302写数据 参数格式:地址,数据*/
  558. void w1302(uchar w_adder,uchar w_data)
  559. {
  560.   uchar d;
  561.   ret_ds1302();
  562.   for(d=0;d<16;d++)
  563.   {
  564.     if(d==8) w_adder=w_data;
  565.         d02_data=(bit)(w_adder&0x01);
  566.     d02_sclk=0;                 // 上升沿
  567.     w_adder>>=1;
  568.     d02_sclk=1;
  569.   }
  570.   end_ds1302();   
  571. }



  572. /*接收1302一个字节的数据 参数格式:读地址*/
  573. uchar r1302(uchar r_adder)
  574. {
  575.   uchar d=0;
  576.   ret_ds1302();
  577.   for(d=0;d<8;d++)         // 写地址
  578.   {
  579.     d02_data=(bit)(r_adder&0x01);
  580.     d02_sclk=0;
  581.     r_adder>>=1;
  582.     d02_sclk=1;
  583.   }
  584.   r_adder=0;
  585.   for(d=0;d<8;d++)         // 读数据
  586.   {
  587.         d02_data=1;
  588.         d02_sclk=1;                 // 下降沿
  589.         r_adder>>=1;
  590.         d02_sclk=0;
  591.         if(d02_data) r_adder|=0x80;
  592.   }
  593.   end_ds1302();
  594.   return(r_adder);
  595. }



  596. /*写入时间与日期*/
  597. void wds1302_time_date(void)
  598. {
  599.   w1302(d02_wrc,0x00);                            // 写允许
  600.   w1302(0x90,0xa5);                  // 单二极管2K电阻充电
  601.   w1302(d02_year,today.year);            // 年
  602.   w1302(d02_weeks,today.week);           // 星期
  603.   w1302(d02_month,today.month);            // 月
  604.   w1302(d02_day,today.day);                    // 日
  605.   w1302(d02_hour,0x7f&now.hour);            // 时
  606.   w1302(d02_minute,now.minute);            // 分
  607.   w1302(d02_second,0x7f&now.second); // 秒
  608.   w1302(d02_wrc,0x80);                                  // 写禁止
  609. }




  610. /*初始化写DS1302 RAM*/
  611. void init_wds1302_ram(void)
  612. {
  613.   w1302(d02_wrc,0x00);
  614.   w1302(0x90,0xa5);         // 单二极管2K电阻充电
  615.   w1302(d02_signs,0x00);           // 状态寄存
  616.   w1302(d02_passw,0x74);           // 密码储存首位
  617.   w1302(d02_passw+2,0x14);  // 初始值为:741456
  618.   w1302(d02_passw+4,0x56);  // 密码最后一位
  619.   w1302(d02_alm,0x12);           // 闹铃时(12小时)
  620.   w1302(d02_alm+2,0x00);           // 闹铃分(0分)
  621.   w1302(d02_temp,0xff);           // 温度上限(255为关闭)         
  622.   w1302(d02_temp+2,0xff);   // 温度下限(关闭)
  623.   w1302(d02_initsi,0xb4);   // 是否要初始化标记(0xb4为已经初始化)
  624.   w1302(d02_wrc,0x80);
  625. }

  626. /*写DS1302一字节的RAM*/
  627. void wds1302_data(uchar adder,uchar _data)
  628. {
  629.   w1302(d02_wrc,0x00);
  630.   w1302(adder,_data);
  631.   w1302(d02_wrc,0x80);
  632. }


  633. /*读取日期*/
  634. void rds1302_date(void)
  635. {
  636.   
  637.   today.year=r1302(d02_year+1);         
  638.   today.week=r1302(d02_weeks+1);
  639.   today.month=r1302(d02_month+1);
  640.   today.day=r1302(d02_day+1);  
  641. }


  642. /*读取时间*/
  643. void rds1302_time(void)
  644. {
  645.   now.hour=(r1302(d02_hour+1));
  646.   now.minute=r1302(d02_minute+1);
  647.   now.second=r1302(d02_second+1);
  648.   if(now.hour==alarm_time[0]&&now.minute==alarm_time[1]) alm_run=1;
  649.   else                                                                                 // 闹铃时间比较
  650.   {
  651.     alm_run=0;buzstop=0;buzzer=close;
  652.   }
  653. }                                       

  654. /*开机读数据*/
  655. void rds1302_data(void)
  656. {
  657.   signs=r1302(d02_signs+1);
  658.   alarm_time[0]=r1302(d02_alm+1);
  659.   alarm_time[1]=r1302(d02_alm+3);
  660.   als_temp[0]=r1302(d02_temp+1);
  661.   als_temp[1]=r1302(d02_temp+3);                  
  662. }


  663. /*DS1302初始化*/
  664. void init_ds1302(void)
  665. {
  666.   wds1302_time_date();
  667.   init_wds1302_ram();
  668. }


  669. /*=====================================================================================
  670. 函数名称:DS18b20驱动
  671. 功能描述:基本驱动(读写数据、数据转换、初始化)
  672. 全局变量:无
  673. 参数说明:无
  674. 返回说明:返回读取的数据
  675. 设 计 人:LIJH
  676. 版    本:1.0
  677. 说    明:调试中。。。
  678. ======================================================================================*/



  679. /*18B20初始化*/
  680. void init_ds18b20()
  681. {
  682.   b20_io=1;
  683.   b20_io=0;
  684.   delay_b20(120);                // 延时≥480us
  685.   b20_io=1;
  686.   delay_b20(12);            // 拉高为高电平后在15—60us出现低电平,并维持60—240us
  687.   ds18b20=~b20_io;
  688.   delay_b20(40);        
  689. }


  690. /*向18B20发送一个字节*/
  691. void send18b20_byte(uchar data_send)
  692. {
  693.   uchar d=0;
  694.   for (d=0;d<8;d++)
  695.   {
  696.         b20_io=0;                                        // 拉低电平后向总线写入一个位,15us后18B20接收  
  697.     b20_io=data_send&0x01;            
  698.     delay_b20(10);                                // 延时60us后完成一次
  699.     b20_io=1;
  700.     data_send>>=1;                            // 下位开始
  701.   }
  702. }


  703. /*从18B20读出温度值 12位分辨率*/  
  704. void receive18b20(void)
  705. {
  706.   uchar n=1,d;
  707.   for (d=0;d<16;d++)
  708.   {
  709.         if(d==8) n=0;
  710.         b20_io=0;                                          // 拉低总线
  711.         temp.t_data[n]>>=1;            
  712.         b20_io=1;                     // 拉高总线
  713.         if(b20_io)                                          // 读入总线数值
  714.       temp.t_data[n]|=0x80;
  715.     delay_b20(10);                                  // 等待60us
  716.   }
  717. }


  718. /*数据转化*/
  719. void conversion_t(void)
  720. {
  721.   uchar save=0,save1=0;
  722.   if(temp.temp_data<0)                  // 判断数值符号
  723.     {temp_pn=1;temp.temp_data=~temp.temp_data+1;}
  724.   else temp_pn=0;
  725.   if(temp.t_data[1]&0x01==1) save+=6;            // 小数点后的值转变
  726.   if((temp.t_data[1]>>1)&0x01==1) save+=12;
  727.   if((temp.t_data[1]>>2)&0x01==1) save+=25;
  728.   if((temp.t_data[1]>>3)&0x01==1) save+=50;
  729.   temp.temp_data>>=4;
  730.   save1=temp.temp_data&0x00ff;                                // 整数部分数值
  731.   temp.t_data[0]=save1;
  732.   temp.t_data[1]=save;
  733.   thl_als=1;
  734.   if(save1>=(als_temp[0]&0x7f))      // 温度比较
  735.   {
  736.         if(!temp_pn||(temp_pn&(als_temp[0]&0x80)!=0)){ als_th=open;als_tl=close;}
  737.   }
  738.   else if(save1<(als_temp[1]&0x7f)&&als_temp[1]!=255)
  739.   {
  740.     if(!temp_pn||(temp_pn&(als_temp[1]&0x80)!=0)) {als_tl=open;als_th=close;}
  741.   }
  742.   else {als_th=als_tl=close;thl_als=0;buzstop=0;buzzer=close;}
  743. }



  744. /*18b20功能*/
  745. void ds18b20_func(void)
  746. {
  747.   EA=0;
  748.   TR0=0;
  749.   temp.temp_data=0;
  750.   init_ds18b20();
  751.   send18b20_byte(0xcc); // 跳过ROM
  752.   send18b20_byte(0x44); // 温度转换
  753.   delay_pw();
  754.   init_ds18b20();
  755.   send18b20_byte(0xcc);
  756.   send18b20_byte(0xbe); // 读RAM
  757.   receive18b20();                // 读取温度值
  758.   conversion_t();                // 数值转换
  759.   EA=1;
  760.   TR0=1;
  761. }



  762. /*=====================================================================================
  763. 函数名称:画面构造
  764. 功能描述:界面1、2、3,图片菜单,反白,标头,16*16(32)图片
  765. 全局变量:无
  766. 参数说明:函数说明
  767. 返回说明:无
  768. 设 计 人:LIJH
  769. 版    本:1.0
  770. 说    明:X坐标每一格每次16点
  771. ======================================================================================*/


  772. /*反白或显示图片 参数格式:(H)8bit数据,(L)8bit数据,X0坐标(16bit),Y0坐标(1bit),X坐标(16bit),Y坐标(1bit)*/
  773. void con_disp (uchar data1,uchar data2,uchar x0,uchar y0,uchar xl,uchar yl)
  774. {
  775.   uchar i,j;
  776.   for(j=0;j<yl;j++)
  777.   {
  778.     for(i=0;i<xl;i++)
  779.     {
  780.       wr_lcd(comm,0x34);     // 扩展功能
  781.       wr_lcd(comm,y0+j);         // 写Y坐标
  782.       wr_lcd(comm,x0+i);         // 写X坐标
  783.       wr_lcd(comm,0x30);         // 普通功能
  784.       wr_lcd(dat,data1);
  785.       wr_lcd(dat,data2);
  786.     }
  787.   }
  788.   wr_lcd(comm,0x36);                 // 开绘图显示
  789. }



  790. /*显示字体 参数格式: 显示位置(0x80-0x9f),显示个数,显示内容指针*/
  791. void display_cnasc(uchar dis_bit,uchar num,uchar *cnasc)
  792. {
  793.   wr_lcd(comm,0x30);             // 普通功能
  794.   wr_lcd(comm,dis_bit);             // 写地址
  795.   while(num>0)
  796.   {
  797.     wr_lcd(dat,*(cnasc++));
  798.     wr_lcd(dat,*(cnasc++));
  799.         num--;
  800.   }
  801. }



  802. /*导航标头显示*/
  803. void dis_title(void)
  804. {
  805.   display_cnasc(0x80,1,"\x15 ");
  806.   display_cnasc(0x90,1,"┏");
  807.   display_cnasc(0x97,1,"┓");
  808.   display_cnasc(0x98,1,"┗");
  809.   display_cnasc(0x9f,1,"┛");
  810.   display_cnasc(0x92,1,"\x1e ");
  811.   display_cnasc(0x9a,1,"\x1f ");
  812.   con_disp(0xff,0xff,0x80,0x80,3,16);
  813.   con_disp(0xef,0xef,0x83,0x80,1,16);
  814.   con_disp(0xde,0xf7,0x84,0x80,1,16);
  815.   con_disp(0x76,0xdb,0x85,0x80,1,16);
  816.   con_disp(0x55,0x55,0x86,0x80,1,16);
  817.   con_disp(0x55,0x55,0x87,0x80,1,16);        
  818. }


  819. /*图片显示标头*/
  820. void dis_title_pic(void)
  821. {
  822.   display_cnasc(0x80,2,"〓〓");
  823.   display_cnasc(0x86,2,"〓〓");
  824. }


  825. /*功能实现显示标头*/
  826. void dis_title_e(void)
  827. {
  828.   display_cnasc(0x80,1," \x15");
  829.   con_disp(0xff,0xff,0x80,0x80,1,16);
  830.   con_disp(0xff,0xc7,0x81,0x80,1,16);
  831.   con_disp(0xff,0xff,0x82,0x80,3,16);
  832.   con_disp(0xe3,0xff,0x85,0x80,1,16);
  833.   con_disp(0xff,0xff,0x86,0x80,2,16);
  834. }



  835. /*显示菜单图片  格式:图片反显(1)或正常显示(0),显示图片的号码*/
  836. void anti_nor_pic (uchar cpl_sign,uchar menu_num)
  837. {
  838.   uchar i,j,x,y;
  839.   x=menu_num*3;           // 计算图片显示坐标
  840.   if(x>6) x--;
  841.   if(menu_num<3) y=16;        // 上下半屏显示
  842.   else y=8;
  843.   if(cpl_sign==1) display_cnasc(0x82,4,menu_cn[menu_num]);
  844.   for(j=0;j<24;j++)
  845.   {
  846.    for(i=0;i<2;i++)
  847.    {
  848.      wr_lcd(comm,0x34);
  849.      wr_lcd(comm,0x80+y);
  850.      wr_lcd(comm,0x80+x+i);  // 分两次显示 16bit
  851.      wr_lcd(comm,0x30);
  852.      if(cpl_sign==1)              // 图片反选
  853.      {
  854.            wr_lcd(dat,~menu_pic[menu_num][j*4+i*2]);
  855.        wr_lcd(dat,~menu_pic[menu_num][j*4+i*2+1]);
  856.          }
  857.      else                                          // 正常显示
  858.      {
  859.            wr_lcd(dat,menu_pic[menu_num][j*4+i*2]);
  860.        wr_lcd(dat,menu_pic[menu_num][j*4+i*2+1]);
  861.          }
  862.    }
  863.    y++;
  864.    if(y==32&&menu_num<3) {x+=8;y=0;}  // 上下屏切换
  865.   }
  866.   wr_lcd(comm,0x36);
  867. }




  868. /*状态16*16图片  格式:反色(1)或正常0,X坐标,Y坐标,状态编码(16*16)*/
  869. void dis_run_state(uchar cpl,uchar x0,uchar y0,uchar state_num)
  870. {
  871.   uchar j;
  872.   for(j=0;j<16;j++)
  873.   {
  874.     wr_lcd(comm,0x34);  // 扩展功能
  875.     wr_lcd(comm,y0++);        // 写Y地址
  876.     wr_lcd(comm,x0);        // 写X地址
  877.     wr_lcd(comm,0x30);        // 普通功能
  878.         if(cpl==1)                        // 写数据
  879.     {
  880.           wr_lcd(dat,~running[state_num][j*2]);
  881.       wr_lcd(dat,~running[state_num][j*2+1]);
  882.         }
  883.         else
  884.         {
  885.           wr_lcd(dat,running[state_num][j*2]);
  886.       wr_lcd(dat,running[state_num][j*2+1]);
  887.         }
  888.   }
  889.   wr_lcd(comm,0x36);
  890. }



  891. /*显示菜单按钮  参数格式:反色(1)或正常(0)*/
  892. void dis_menu_key(uchar d)
  893. {
  894.   if(d==1)
  895.   {
  896.     for(d=0;d<8;d++)                                                                  // 显示菜单按钮
  897.       con_disp(~menu_key[d*2],~menu_key[d*2+1],0x9f,0x97+d,1,1);
  898.   }
  899.   else
  900.   {
  901.     for(d=0;d<8;d++)                                                                  // 显示菜单按钮
  902.       con_disp(menu_key[d*2],menu_key[d*2+1],0x9f,0x97+d,1,1);
  903.   }
  904. }




  905. /*显示模式3的界面*/
  906. void dis_mode3(void)
  907. {
  908.   uchar i,j,h,l,x_0=0x80,y_0=0x90;
  909.   h=now.hour>>4;       // 分离十位 个位
  910.   l=now.hour&0x0f;
  911.   for(j=0;j<2;j++)
  912.   {
  913.     for(i=0;i<32;i++)  // 十位个位一起读入
  914.     {
  915.       wr_lcd(comm,0x34);
  916.       wr_lcd(comm,y_0++);
  917.       wr_lcd(comm,x_0);
  918.       wr_lcd(comm,0x30);
  919.       wr_lcd(dat,mode_3num[h][i*3]);  // 连续写数据,X坐标自动加1
  920.       wr_lcd(dat,mode_3num[h][i*3+1]);
  921.       wr_lcd(dat,mode_3num[h][i*3+2]);
  922.       wr_lcd(dat,mode_3num[l][i*3]);
  923.       wr_lcd(dat,mode_3num[l][i*3+1]);
  924.       wr_lcd(dat,mode_3num[l][i*3+2]);
  925.       if(y_0==0xa0){x_0=x_0+8;y_0=0x80;}
  926.     }
  927.     x_0=0x84,y_0=0x90;
  928.     h=now.minute>>4;   // 分离十位 个位
  929.     l=now.minute&0x0f;
  930.   }
  931.   dis_run_state(0,0x83,0x90,4); // 显示点
  932.   dis_run_state(0,0x8b,0x80,4);                                          
  933.   y_0=0x80;                           // 显示状态标记
  934.   if(keb) {dis_run_state(0,0x87,y_0,2);y_0+=16;}
  935.   if(alm) {dis_run_state(0,0x87,y_0,1);y_0+=16;}
  936.   if(y_0<0xa0&&!als){dis_run_state(0,0x87,y_0,0);}
  937.   if(y_0==0xa0&&!als){dis_run_state(0,0x8f,0x80,0);}
  938.   dis_menu_key(0);
  939. }




  940. /*显示模式1和2的共用部分*/
  941. void mode1_2_union(void)
  942. {
  943.   uchar x=0x9b;
  944.   display_cnasc(0x98,2,"星期");
  945.   if(nba_tim) dis_run_state(0,x,0x90,6);
  946.   if(keb) {dis_run_state(0,x,0x90,2);x++;}    // 显示标记
  947.   if(alm) {dis_run_state(0,x,0x90,1);x++;}
  948.   if(!als){dis_run_state(0,x,0x90,0);}
  949.   dis_menu_key(0);                           // 显示菜单按钮
  950. }


  951. /*显示模式2的日期*/
  952. void dis_date_mode2(uchar d)
  953. {
  954.   uchar save[2];
  955.   display_cnasc(d+2,1,"年");
  956.   display_cnasc(d+4,1,"月");
  957.   display_cnasc(d+6,1,"日");
  958.   display_cnasc(0x9a,1,weeks[today.week]);  // 显示星期
  959.   save[0]=char_num[today.year>>4];                // 将显示的数值存到数组中
  960.   save[1]=char_num[today.year&0x0f];
  961.   display_cnasc(d+1,1,save);
  962.   save[0]=char_num[today.month>>4];
  963.   save[1]=char_num[today.month&0x0f];
  964.   display_cnasc(d+3,1,save);
  965.   save[0]=char_num[today.day>>4];
  966.   save[1]=char_num[today.day&0x0f];
  967.   display_cnasc(d+5,1,save);
  968. }

  969. /*显示模式2的时间数字显示  16*32*/
  970. void num2_asc_dis(uchar num,uchar x_0)
  971. {
  972.   uchar i,y_0=0x90;
  973.   for(i=0;i<32;i++)  // 十位个位一起读入
  974.   {
  975.     wr_lcd(comm,0x36);
  976.     wr_lcd(comm,y_0++);
  977.     wr_lcd(comm,x_0);
  978.     wr_lcd(comm,0x30);
  979.     wr_lcd(dat,mode_2num[num][i*2]);
  980.     wr_lcd(dat,mode_2num[num][i*2+1]);
  981.         if(i==15){x_0+=8;y_0=0x80;}
  982.   }
  983.   wr_lcd(comm,0x36);
  984. }

  985. /*显示模式2的时间*/
  986. void dis_time_mode2(void)
  987. {
  988.   uchar h,l;
  989.   if(now.hour!=save_time.hour||init_d2)
  990.   {
  991.     h=now.hour>>4;    // 分离十位 个位
  992.     l=now.hour&0x0f;
  993.     num2_asc_dis(h,0x80);
  994.         num2_asc_dis(l,0x80+1);
  995.   }
  996.   if(now.minute!=save_time.minute||init_d2)
  997.   {
  998.     h=now.minute>>4;    // 分离十位 个位
  999.     l=now.minute&0x0f;
  1000.     num2_asc_dis(h,0x83);
  1001.         num2_asc_dis(l,0x83+1);
  1002.   }
  1003.   if(now.second!=save_time.second||init_d2)
  1004.   {
  1005.     h=now.second>>4;    // 分离十位 个位
  1006.     l=now.second&0x0f;
  1007.     num2_asc_dis(h,0x86);
  1008.         num2_asc_dis(l,0x86+1);
  1009.   }
  1010.   if(init_d2)
  1011.   {
  1012.     dis_run_state(0,0x82,0x90,5); // 显示点
  1013.     dis_run_state(0,0x8a,0x80,5);
  1014.     dis_run_state(0,0x85,0x90,5); // 显示点
  1015.     dis_run_state(0,0x8d,0x80,5);
  1016.   }        
  1017. }


  1018. /*显示模式2的界面*/
  1019. void dis_mode2(void)
  1020. {
  1021.   dis_date_mode2(0x81);              // 显示日期
  1022.   display_cnasc(0x81,1,"20");
  1023.   dis_time_mode2();                          // 显示时间
  1024.   mode1_2_union();
  1025. }


  1026. /*显示模式1的日期*/
  1027. void dis_date_mode1(void)
  1028. {
  1029.   uchar save[2];
  1030.   display_cnasc(0x80,3,"日期:");
  1031.   display_cnasc(0x90,3,"时间:");
  1032.   display_cnasc(0x88,3,"温度:");
  1033.   display_cnasc(0x9a,1,weeks[today.week]);  // 显示星期
  1034.   display_cnasc(0x83,1,"20");
  1035.   save[0]=char_num[today.year>>4];                          
  1036.   save[1]=char_num[today.year&0x0f];
  1037.   display_cnasc(0x84,1,save);
  1038.   save[0]='/';
  1039.   save[1]=char_num[today.month>>4];
  1040.   display_cnasc(0x85,1,save);
  1041.   save[0]=char_num[today.month&0x0f];
  1042.   save[1]='/';
  1043.   display_cnasc(0x86,1,save);
  1044.   save[0]=char_num[today.day>>4];
  1045.   save[1]=char_num[today.day&0x0f];
  1046.   display_cnasc(0x87,1,save);
  1047.   mode1_2_union();
  1048. }


  1049. /*显示模式1的时间*/
  1050. void dis_time_mode1(void)
  1051. {
  1052.   uchar save[2];
  1053.   save[0]=char_num[now.hour>>4];
  1054.   save[1]=char_num[now.hour&0x0f];
  1055.   display_cnasc(0x93,1,save);
  1056.   save[0]=':';
  1057.   save[1]=char_num[now.minute>>4];
  1058.   display_cnasc(0x94,1,save);
  1059.   save[0]=char_num[now.minute&0x0f];
  1060.   save[1]=':';
  1061.   display_cnasc(0x95,1,save);
  1062.   save[0]=char_num[now.second>>4];
  1063.   save[1]=char_num[now.second&0x0f];
  1064.   display_cnasc(0x96,1,save);
  1065. }


  1066. /*显示模式1的温度*/
  1067. void dis_temp_mode1(void)
  1068. {
  1069.   uchar save[2];
  1070.   if(ds18b20)
  1071.   {
  1072.          if(temp.t_data[0]>99)
  1073.          {
  1074.             save[0]=char_num[temp.t_data[0]/100];
  1075.                 save[1]=char_num[(temp.t_data[0]/10)%10];
  1076.                 display_cnasc(0x8b,1,save);
  1077.                 save[0]=char_num[temp.t_data[0]%10];
  1078.                 save[1]='.';
  1079.                 display_cnasc(0x8c,1,save);
  1080.                 save[0]=char_num[temp.t_data[1]/10];
  1081.                 save[1]=' ';
  1082.                 display_cnasc(0x8d,1,save);
  1083.                 display_cnasc(0x8e,1,"℃");
  1084.           }
  1085.           else
  1086.           {
  1087.         if(temp_pn) display_cnasc(0x8a,1,":-");
  1088.             else  display_cnasc(0x8a,1,":");
  1089.                 save[0]=char_num[temp.t_data[0]/10];
  1090.                 save[1]=char_num[temp.t_data[0]%10];
  1091.                 display_cnasc(0x8b,1,save);
  1092.                 save[0]='.';
  1093.                 save[1]=char_num[temp.t_data[1]/10];
  1094.                 display_cnasc(0x8c,1,save);
  1095.                 display_cnasc(0x8d,1,"℃");
  1096.           }
  1097.         }
  1098.   else display_cnasc(0x8b,3,"FF.F℃");
  1099. }



  1100. /*显示模式1的界面*/
  1101. void dis_mode1(void)
  1102. {
  1103.   dis_date_mode1();
  1104.   dis_time_mode1();
  1105.   dis_temp_mode1();
  1106. }



  1107. /*篮球器时间显示*/
  1108. void nba_dis_time(void)
  1109. {
  1110.   uchar d,dis[2];
  1111.   for(d=2;d<4;d++)
  1112.   {
  1113.         dis[0]=char_num[resu[d]/10];
  1114.         dis[1]=char_num[resu[d]%10];
  1115.         display_cnasc(0x81+d*2,1,dis);
  1116.   }
  1117.   display_cnasc(0x86,1,": ");
  1118.   if(resu[0]==1)
  1119.   {
  1120.         dis[0]='\x07';
  1121.         dis[1]=char_num[resu[4]/10];
  1122.         display_cnasc(0x93,1,dis);
  1123.         dis[1]='\x07';
  1124.         dis[0]=char_num[resu[4]%10];
  1125.         display_cnasc(0x94,1,dis);
  1126.   }
  1127. }


  1128. /*=====================================================================================
  1129. 函数名称:键盘扫描
  1130. 功能描述:读取键盘操作数据及部分状态的实现
  1131. 全局变量:dis_sig  t0_isr  temprun  b20time  alm_run als_temp         buzstop  als
  1132.            lock_op  nba_tim
  1133. 参数说明:无
  1134. 返回说明:键盘锁与密码锁时间到达后返回 255
  1135. 设 计 人:LIJH
  1136. 版    本:1.0
  1137. 说    明:
  1138. ======================================================================================*/

  1139. /*扫描键盘*/
  1140. uchar  keypad_scan()
  1141. {
  1142.   uchar key,dis[2];
  1143.   keyboard=0xf0;
  1144.   while (keyboard==0xf0)     // 等待按键按下
  1145.   {         

  1146.   /*--------------------- 背光灯关闭延时 -----------------------*/
  1147.         
  1148.         delay(1000);                                      
  1149.         if((++dis[0])==0&&bl_delay!=0) bl_delay--;  // 当有按键按下bl_delay重新赋值         
  1150.         if(bl_delay==0&&!bl0) lcd_bl=close;         // 背光时间到且不是常开模式时关闭背光

  1151.          
  1152.   /*----------------------- 键盘锁延时 -------------------------*/        

  1153.         if(keb&&dis_sig&&bl_delay==0&&resu[11]<2) resu[11]++; // 当有按键按下j清零
  1154.         if(bl_delay==0) bl_delay=15;


  1155.   /*--------------------- 密码锁30秒锁延时 ---------------------*/               

  1156.         if(lock_op)                                         
  1157.         {
  1158.           if((++i)==0) save1++;                  
  1159.           if(save1==15) return(255);
  1160.         }
  1161.         

  1162.   /*---------------------- 时钟界面时间显示 ---------------------*/
  1163.         
  1164.         if(dis_sig&&t0_isr||nba_tim&&oth_run)     // 正常时钟界面与篮球器返回时钟界面显示
  1165.     {   
  1166.           rds1302_date();            // 读出日期
  1167.       rds1302_time();                // 读出时间
  1168.           if(di0)                     // 模式2
  1169.           {
  1170.             dis_time_mode2();
  1171.                 if(now.hour==0&&now.minute==0&&now.second==0)        dis_date_mode2(0x81);
  1172.           }
  1173.       else if(di1)                         // 模式3
  1174.           {
  1175.             if(now.hour!=save_time.hour||now.minute!=save_time.minute)   // 时,分变化后显示
  1176.               dis_mode3();           
  1177.       }
  1178.       else
  1179.           {
  1180.             dis_time_mode1();   // 模式1
  1181.             if(now.hour==0&&now.minute==0&&now.second==0) dis_date_mode1();
  1182.           }
  1183.           save_time=now;        // 重新记录作下次比较
  1184.           t0_isr=0;
  1185.         }
  1186.   
  1187.   
  1188.   /*-------------------- 温度计提示按键操作 ----------------------*/
  1189.          
  1190.         if(temprun)
  1191.         {
  1192.           if(!oth_run)
  1193.           {
  1194.             display_cnasc(0x96,2," key");    // 温度计时提示按键操作
  1195.                 for(dis[1]=0;dis[1]<250;dis[1]++)
  1196.             {
  1197.               delay(1000);
  1198.                   if(keyboard!=0xf0)
  1199.                   {
  1200.                     keyboard=0x7f;
  1201.                         if(keyboard==0x7d) return 0x7d;
  1202.                         else  keyboard=0xf0;
  1203.                   }
  1204.             }
  1205.                 oth_run=1;
  1206.                 display_cnasc(0x96,2,"    ");
  1207.           }
  1208.         }
  1209.   
  1210.   
  1211.    /*------------------------ 蜂鸣器警报 --------------------------*/

  1212.         
  1213.         if(((alm_run&&alm)||thl_als)&&!buzstop)        // 温度,闹铃蜂鸣器警报
  1214.         {                                                                            // 有按键按下时停止
  1215.           if(now.second==0)        lcd_bl=close;
  1216.           delay(15000);                                                        // 读出温度时间比较
  1217.           if(keyboard!=0xf0) break;
  1218.           delay(15000);
  1219.           if(keyboard!=0xf0) break;
  1220.           delay(15000);
  1221.           if(keyboard!=0xf0) break;
  1222.           delay(15000);
  1223.           if(alm_run)  lcd_bl=!lcd_bl;                        // 只在闹铃功能闪
  1224.           if(!als)buzzer=!buzzer;               // 警报开启后蜂鸣器开启                           
  1225.         }


  1226.   /*----------------------- 温度刷新显示 -------------------------*/

  1227.          
  1228.         if((temprun&&oth_run)||(b20time&&!di0&&!di1&&dis_sig))    // 温度计功能于模式1界面
  1229.     {  
  1230.          
  1231.             ds18b20_func();                                                  // 温度检测功能
  1232.                 oth_run=0;                                    // 作交替标记用
  1233.             if(temprun) return 20;                              // 温度计开启后返回
  1234.             if(b20time){ dis_temp_mode1();b20time=0;} // 时钟界面5分钟更新一次,T0计时
  1235.     }

  1236.   
  1237.    
  1238.    /*------------------------ 篮球器显示时间 ------------------------*/
  1239.         
  1240.         if(nba_tim&!oth_run)            // 当篮球器模式下 oth_run==0为篮球器计时状态
  1241.         {
  1242.           if(EA) display_cnasc(0x8b,2," R\x10 ");  // 显示运行状态
  1243.           else  display_cnasc(0x8b,2," S! ");
  1244.           if(t0_isr)
  1245.           {                                                                                   // 更新时间
  1246.             nba_dis_time();
  1247.                 if(resu[2]==0&&resu[3]==0)                           // 判断比赛情况
  1248.                 {
  1249.                   resu[6]++;
  1250.                   if(resu[6]<resu[1])  display_cnasc(0x85,3,"休息  ");
  1251.                   else  display_cnasc(0x85,3,"完结  ");
  1252.                 }
  1253.                 if(resu[4]==0||(resu[2]==0&&resu[3]==0))  // 时间到达警报
  1254.             {
  1255.                buzzer=open;
  1256.                delay_pw();
  1257.                    if(resu[2]==0&&resu[3]==0)  // 24秒 总时间警报
  1258.                    {
  1259.                      delay_pw();
  1260.                    }
  1261.                buzzer=close;
  1262.                    if(resu[4]==0) resu[4]=24;  // 重新赋值
  1263.             }
  1264.             t0_isr=0;                                           // 清零等下次中断产生
  1265.           }
  1266.         }
  1267.   }

  1268.                           
  1269.                                 /*===== 以上等待按键 =====*/



  1270.   /*------------------------- 按键按下后 --------------------------*/

  1271.   
  1272.   delay(8000);                      // 消抖振
  1273.   if(!lock_op)bl_delay=15;   // 背光时间赋值
  1274.   if(bl1) lcd_bl=close;             // 不在背光灯关闭时亮起
  1275.   else lcd_bl=open;
  1276.   if(alm_run|thl_als) {buzstop=1;buzzer=close;}
  1277.   if(keb&&dis_sig)
  1278.   {
  1279.     if(resu[11]==2) return 255;  // 要求输入密码        
  1280.           else resu[11]=0;                         // 时间不到时重新计时
  1281.   }
  1282.   do
  1283.   {            
  1284.         for(dis[0]=0;dis[0]<=3;dis[0]++)
  1285.     {
  1286.       keyboard=ksp[dis[0]];
  1287.           if(keyboard!=ksp[dis[0]])
  1288.       {        
  1289.         key=keyboard;
  1290.         if(key!=ksp[dis[0]]) return(key);
  1291.       }
  1292.     }
  1293.   }while(1);
  1294. }


  1295. /*读键盘数据*/
  1296. uchar  gotkey()
  1297. {
  1298.   uchar  save,n;
  1299.   keyboard=0xf0;
  1300.   while(keyboard!=0xf0);    // 等待键盘松开
  1301.   delay(5000);                    // 消抖阵
  1302.   if(adju_si)                     // 连写输入
  1303.   {
  1304.         adju_si=0;
  1305.         for(n=0;n<60;n++)
  1306.           {
  1307.           delay(2000);
  1308.           if(keyboard!=0xf0)
  1309.           {
  1310.             adju_si=1;          // 在更改时,在此时间内可连成多位数
  1311.              break;
  1312.           }
  1313.     }
  1314.   }                        
  1315.   save=keypad_scan();            // 扫描键盘
  1316.   if(save==255)        return 255;        // 要求输入键盘锁密码或延时时间到达
  1317.   for (n=0;n<16;n++)
  1318.   {  
  1319.         if(save==key_code[n])
  1320.            return(n);
  1321.   }
  1322.   return(20);
  1323. }



  1324. /*=====================================================================================
  1325. 函数名称:导航
  1326. 功能描述:主菜单 工具导航  保存提示
  1327. 全局变量:无
  1328. 参数说明:
  1329. 返回说明:无
  1330. 设 计 人:LIJH
  1331. 版    本:1.0
  1332. 说    明:
  1333. ======================================================================================*/


  1334. /*按键按下显示 参数格式:k 按钮的显示地址*/
  1335. void key_dis(uchar k)
  1336. {
  1337.   display_cnasc(k,1,"\x04 ");
  1338.   delay(10000);
  1339.   if(k==0x92||k==0x96) display_cnasc(k,1,"\x1e ");
  1340.   else display_cnasc(k,1,"\x1f ");
  1341. }



  1342. /*确定按键按下显示*/
  1343. void enter_dis(void)
  1344. {
  1345.   display_cnasc(0x8f,1," \x09");
  1346.   delay(15000);
  1347. }



  1348. /*主菜单导航*/
  1349. uchar dis_menu(void)
  1350. {
  1351.   uchar d,save,key;
  1352.   if(meu)
  1353.   {  
  1354.     display_cnasc(0x81,2,"菜单");
  1355.         dis_title();
  1356.         display_cnasc(0x88,8,selected[0]);
  1357.         con_disp(0xff,0xff,0x8a,0x80,5,16);
  1358.   }
  1359.   else          // 显示图片菜单
  1360.   {
  1361.     dis_title_pic();
  1362.         for(d=0;d<6;d++)  
  1363.       anti_nor_pic(0,d);
  1364.         anti_nor_pic(1,0);
  1365.   }      
  1366.   save=d=0;
  1367.   do
  1368.   {
  1369.         if(meu)          // 操作指示更新
  1370.         {         
  1371.           display_cnasc(0x93,3,menu_cn_2[index_m[save].left_num]);
  1372.           display_cnasc(0x8b,3,menu_cn_2[save]);
  1373.           display_cnasc(0x9b,3,menu_cn_2[index_m[save].right_num]);
  1374.     }
  1375.         else
  1376.         {
  1377.           anti_nor_pic(0,d);     
  1378.           anti_nor_pic(1,save);
  1379.         }
  1380.         d=save;                              // 保存上一索引
  1381.         while(1)
  1382.         {
  1383.           key=gotkey();
  1384.           if(key==11||(key==3&&meu))
  1385.           {
  1386.             if(meu) enter_dis();
  1387.                 break;
  1388.           }
  1389.           else if(meu)
  1390.           {
  1391.             if(key==2)
  1392.                 {
  1393.                   save=index_m[d].right_num;
  1394.                   key_dis(0x9a);
  1395.                   break;
  1396.                 }
  1397.             if(key==5)
  1398.                 {
  1399.                   save=index_m[d].left_num;
  1400.                   key_dis(0x92);
  1401.                   break;
  1402.                 }
  1403.                 if((key==1&&meu))
  1404.             {
  1405.               d=5;
  1406.                   break;
  1407.             }
  1408.           }
  1409.           else
  1410.           {
  1411.             if(key==3){save=index_m[d].right_num; break;} // 根据导航键寻找索引
  1412.             if(key==1){save=index_m[d].left_num; break;}
  1413.                 if(key==2||key==5){save=index_m[d].shaft_num; break;}  
  1414.       }
  1415.         }
  1416.         if(key==11||((key==1|key==3)&&meu)) break;
  1417.   }while(1);
  1418.   return d;
  1419. }



  1420. /*工具导航*/
  1421. uchar tool_func(void)
  1422. {
  1423.   uchar save,d,key;
  1424.   display_cnasc(0x81,2,"工具");
  1425.   dis_title();
  1426.   display_cnasc(0x88,8,selected[0]);
  1427.   con_disp(0xff,0xff,0x8a,0x80,5,16);
  1428.   d=0;
  1429.   save=0;
  1430.   do
  1431.   {         
  1432.         display_cnasc(0x93,3,tool_menu[index_t[save].lnum]);
  1433.         display_cnasc(0x8b,3,tool_menu[save]);
  1434.         display_cnasc(0x9b,3,tool_menu[index_t[save].rnum]);
  1435.         d=save;
  1436.         while(1)
  1437.         {
  1438.           key=gotkey();
  1439.           if(key==1){ d=4;break;}                                // 根据按键寻找索引
  1440.           if(key==11||key==3){enter_dis();break;}
  1441.           if(key==2){save=index_t[d].rnum; key_dis(0x9a);break;}
  1442.           if(key==5){save=index_t[d].lnum; key_dis(0x92);break;}
  1443.     }
  1444.         if(key==11||key==3||key==1) break;
  1445.   }while(1);
  1446.   return d;
  1447. }




  1448. /*更改后提示保存*/
  1449. void save_y_or_n(void)
  1450. {
  1451.   uchar key;
  1452.   clear_dis();
  1453.   oth_run=0;         
  1454.   display_cnasc(0x92,5,"是否保存? ");
  1455.   display_cnasc(0x89,6,"Y(OK)\\N(./S)");
  1456.   while(1)
  1457.   {
  1458.         key=gotkey();
  1459.         if(key==11)
  1460.         {
  1461.           display_cnasc(0x9a,5,"保存成功! ");
  1462.           delay(50000);
  1463.           oth_run=1;         // 要求保存时oth_run标记为1
  1464.           return;
  1465.         }
  1466.         if(key==10) return;
  1467.   }
  1468. }


  1469. /*=====================================================================================
  1470. 函数名称:调整功能
  1471. 功能描述:时间日期调整
  1472. 全局变量:today  now
  1473. 参数说明:见函数
  1474. 返回说明:无
  1475. 设 计 人:LIJH
  1476. 版    本:1.0
  1477. 说    明:
  1478. ======================================================================================*/


  1479. /*调整功能显示时间*/
  1480. void asjust_time()
  1481. {
  1482.   uchar save[2];
  1483.   display_cnasc(0x8a,1,"时");
  1484.   display_cnasc(0x8c,1,"分");
  1485.   display_cnasc(0x8e,1,"秒");
  1486.   save[0]=char_num[now.hour>>4];
  1487.   save[1]=char_num[now.hour&0x0f];
  1488.   display_cnasc(0x89,1,save);
  1489.   save[0]=char_num[now.minute>>4];
  1490.   save[1]=char_num[now.minute&0x0f];
  1491.   display_cnasc(0x8b,1,save);
  1492.   save[0]=char_num[now.second>>4];
  1493.   save[1]=char_num[now.second&0x0f];
  1494.   display_cnasc(0x8d,1,save);
  1495. }


  1496. /*调整功能月天数比较*/
  1497. uchar monthday(uchar year,uchar month)
  1498. {
  1499.   if(month==2&&year%4==0)
  1500.     return(29);
  1501.   else
  1502.   {        year=month&0x0f;
  1503.     month>>=4;
  1504.         month=month*10+year;        
  1505.     return(dayofmonth[month-1]);}
  1506. }



  1507. /*星期推算*/
  1508. void weeks_day()
  1509. {
  1510.   uchar d,buffer,day=4;
  1511.   if(today.month>1)
  1512.   {
  1513.     buffer=(today.month>>4);   // 将BCD码转为十进制
  1514.         buffer=buffer*10;
  1515.         buffer+=(today.month&0x0f);
  1516.         for(d=0;d<buffer-1;d++)
  1517.         {
  1518.           today.week=(dayofmonth[d]>>4);
  1519.           today.week=today.week*10;
  1520.           today.week+=(dayofmonth[d]&0x0f);
  1521.       day+=(today.week%7);
  1522.         }
  1523.   }
  1524.   buffer=(today.year>>4);
  1525.   buffer*=10;
  1526.   buffer+=(today.year&0x0f);
  1527.   if(today.year!=0)
  1528.   {
  1529.         day+=((buffer-1)/4)+buffer+1;
  1530.   }
  1531.   if(buffer%4==0&&today.month>2) day++;
  1532.   buffer=today.day>>4;
  1533.   buffer*=10;
  1534.   buffer+=(today.day&0x0f);
  1535.   today.week=(day+buffer)%7;
  1536. }



  1537. /*调整功能*/
  1538. void adjust_func(void)
  1539. {
  1540.   uchar d,save,b=0;
  1541.   dis_title_e();
  1542.   display_cnasc(0x82,3,menu_cn_2[0]);
  1543.   rds1302_date();
  1544.   rds1302_time();
  1545.   dis_date_mode2(0x90);
  1546.   display_cnasc(0x9a,1,"  ");
  1547.   asjust_time();
  1548.   display_cnasc(0x9f,1,"→");
  1549.   display_cnasc(0x90,1,"『");
  1550.   display_cnasc(0x8f,1,"』");
  1551.   d=0;save=0;
  1552.   adju_si=0;
  1553.   do
  1554.   {
  1555.     con_disp(0x00,0x00,index_a[d].lnum,index_a[d].rnum,1,13);
  1556.     con_disp(0xff,0xff,index_a[save].lnum,index_a[save].rnum,1,13);
  1557.         d=save;
  1558.         while(1)
  1559.         {
  1560.           save=gotkey();
  1561.           if(save>=0&&save<10)
  1562.           {
  1563.             switch(d)
  1564.             {
  1565.               case 0: if(adju_si) // adju_si==1时两次输入连成一个数
  1566.                           {
  1567.                                     today.year<<=4;
  1568.                                 today.year+=save;adju_si=0;
  1569.                                   }
  1570.                       else
  1571.                               {
  1572.                                 today.year=save;adju_si=1;
  1573.                               }
  1574.                           break;
  1575.                   case 1: if(adju_si)
  1576.                           {
  1577.                                     today.month<<=4;today.month+=save;
  1578.                             if(today.month>0x12) today.month=save;
  1579.                     else adju_si=0;
  1580.                                   }
  1581.                                   else  
  1582.                                   {
  1583.                                     today.month=save;adju_si=1;
  1584.                                   }
  1585.                                   break;
  1586.                   case 2: if(adju_si)
  1587.                           {
  1588.                                     today.day<<=4;today.day+=save;  // 月天数比较
  1589.                                         if(today.year%4==0&&today.month==2&&today.day==29) ;
  1590.                             else if(today.day>monthday(today.year,today.month))
  1591.                                           today.day=save;
  1592.                                         else adju_si=0;
  1593.                                   }
  1594.                                   else  {today.day=save;adju_si=1;}
  1595.                                   break;
  1596.                   case 3: if(adju_si)
  1597.                           {
  1598.                                     now.hour<<=4;now.hour+=save;
  1599.                                           if(now.hour>0x23) now.hour=save;
  1600.                                         else adju_si=0;
  1601.                                   }
  1602.                                   else  {now.hour=save;adju_si=1;}
  1603.                                   break;
  1604.                   case 4: if(adju_si)
  1605.                           {
  1606.                                     now.minute<<=4;now.minute+=save;
  1607.                                           if(now.minute>0x59) now.minute=save;
  1608.                                         else adju_si=0;
  1609.                                   }
  1610.                                   else  {now.minute=save;adju_si=1;}
  1611.                                   break;
  1612.                   case 5: if(adju_si)
  1613.                           {
  1614.                                     now.second<<=4;now.second+=save;
  1615.                                           if(now.second>0x59) now.second=save;
  1616.                                         else adju_si=0;
  1617.                                   }
  1618.                                   else  {now.second=save;adju_si=1;}
  1619.                                   break;
  1620.                 }
  1621.                 if(today.day>monthday(today.year,today.month)) today.day=1;        // 更改月份时判断天数
  1622.                 if(today.month==0) today.month=1;
  1623.                 if(today.day==0) today.day=1;
  1624.                 if(d<3) dis_date_mode2(0x90);         // 更新显示
  1625.         else asjust_time();
  1626.                 display_cnasc(0x9a,1,"  ");                // 消去星期显示
  1627.       }
  1628.           if(save==11){save=d+1;adju_si=0;break;}
  1629.           if(save==10&&d!=0){save=d-1;adju_si=0;break;}
  1630.         }
  1631.     if(save==7&d==6) break;
  1632.   }while(1);
  1633.   weeks_day();          // 计算星期
  1634.   save_y_or_n();  // 需要保存时oth_run设为1
  1635.   if(oth_run) wds1302_time_date();
  1636. }




  1637. /*=====================================================================================
  1638. 函数名称:计算器功能
  1639. 功能描述:10位带符号数的加减乘除运算
  1640. 全局变量:opera  resu  i  j
  1641. 参数说明:见函数
  1642. 返回说明:无
  1643. 设 计 人:LIJH
  1644. 版    本:1.0
  1645. 说    明:
  1646. ======================================================================================*/



  1647. /*清寄存器  参数格式:m=2时结果寄存器,当m=1时操作数1,当m=0时操作数0(1),
  1648.                         n=1时,只清寄存器不清显示, 0两清*/
  1649. void removal_data(uchar m,uchar n)
  1650. {
  1651.   uchar l;                // 当n=1时,只清寄存器不清显示, 0两清
  1652.   if(m==2)                // 当m=2时结果寄存器
  1653.   {                            // 当m=1时操作数1
  1654.     if(n==0)        // 当m=0时操作数0 ,1
  1655.           for(l=0;l<6;l++)
  1656.             display_cnasc(0x98+l,1,"  ");
  1657.     for(l=0;l<12;l++)
  1658.       resu[l]=0;
  1659.   }
  1660.   while(m<2)
  1661.   {
  1662.     if(n==0)
  1663.         {
  1664.           if(m==0)
  1665.           {  
  1666.             for(l=0;l<6;l++)
  1667.               display_cnasc(0x90+l,1,"  ");
  1668.                   display_cnasc(0x95,1," 0");
  1669.           }        
  1670.           else
  1671.              for(l=0;l<6;l++)
  1672.                 display_cnasc(0x88+l,1,"  ");
  1673.         }
  1674.     for(l=0;l<12;l++)
  1675.       opera[m][l]=0;
  1676.         m++;
  1677.   }
  1678. }




  1679. /*显示数值  参数格式:显示首地址*/
  1680. void dis_cdata(uchar ass)
  1681. {
  1682.   uchar p,d,save[2];
  1683.   if(i==0&&opera[0][0]==1)                 // 显示符号
  1684.   {
  1685.     if(cal_run)  display_cnasc(0x98,1,"=-");
  1686.     else  display_cnasc(0x90,1," -");
  1687.   }
  1688.   d=opera[i][11];                                // 计算位数
  1689.   if(opera[i][10]!=0&&opera[i][10]!=opera[i][11]+1) d++;
  1690.   save[0]=d/2;ass=ass-save[0]+5;        // 计算显示的开始位置
  1691.   p=1;
  1692.   cal_del=0;                                        // 显示点标记 (0为没有显示)
  1693.   if(d%2==1)                                        // 对位数位奇数先处理首位
  1694.   {
  1695.     save[0]=' ';
  1696.     save[1]=char_num[opera[i][1]];
  1697.         display_cnasc(ass,1,save);
  1698.         p++;
  1699.   }
  1700.   ass++;                                                // 显示地址加一
  1701.   while(p<=opera[i][11])
  1702.   {                                                                        
  1703.     if(opera[i][10]==p&&(!cal_del)) {   // 显示点且作标记
  1704.           save[0]='.';cal_del=1;}
  1705.     else {
  1706.           save[0]=char_num[opera[i][p]]; p++;}
  1707.     if(opera[i][10]==p&&(!cal_del)) {
  1708.           save[1]='.';cal_del=1;}
  1709.     else{
  1710.           save[1]=char_num[opera[i][p]];p++;}
  1711.     display_cnasc(ass,1,save);
  1712.     ass++;
  1713.   }
  1714. }   


  1715. /*从键盘中写入数据*/   
  1716. char input_data()
  1717. {
  1718.   uchar save=20,c;
  1719.   for(;i<2;i++)
  1720.   {
  1721.     while(1)
  1722.     {
  1723. pp:   save=gotkey();        // 读键盘
  1724.           if(save==20) continue;
  1725.           if(save==11)                // 按键为确定时,选择计算或删除
  1726.           {
  1727.             c=save=0;
  1728.                 while(1)                // 反色选择
  1729.             {
  1730.                   con_disp (0x00,0x00,index_cal[save].lnum,index_cal[save].rnum,2,16);
  1731.                   con_disp (0xff,0xff,index_cal[c].lnum,index_cal[c].rnum,2,16);        
  1732.                   save=gotkey();
  1733.                   if(save==10)
  1734.                   {
  1735.                     save=c;
  1736.                         if(++c==3) c=0;
  1737.                   }
  1738.                   else if(save==11)
  1739.                   {
  1740.             if(c==0) save=11;
  1741.                     else if(c==1) save=16;
  1742.                         else  return 0;
  1743.                     break;
  1744.                   }
  1745.                   else break;
  1746.         }
  1747.                 con_disp (0x00,0x00,index_cal[c].lnum,index_cal[c].rnum,2,16);            
  1748.           }
  1749.       if(save>=0&&save<=9&&j<10)
  1750.           {
  1751.             if(i==1&&opera[1][0]==15&&j>8) goto pp;
  1752.         if(j==2&&opera[i][1]==0&&opera[i][10]==0)
  1753.           opera[i][1]=save;                // 防止小数位不在时首位为零
  1754.             else{
  1755.                   opera[i][j]=save;opera[i][11]=j;j++;}
  1756.                 if(i==0)                                // 显示
  1757.                   dis_cdata(0x90);
  1758.                 else
  1759.                   dis_cdata(0x88);
  1760.           }
  1761.       else if(save==10&&j<10)        
  1762.       {
  1763.             if(opera[i][10]==0)                // 小数点空时保存
  1764.             {
  1765.                   if(opera[i][11]==0) {opera[i][10]=2;j++;}
  1766.               else  opera[i][10]=j;
  1767.             }
  1768.           }
  1769.           else if(save==16)        
  1770.           {                           // 删除数据
  1771.         removal_data(i,0);j=1;
  1772.                 if(i!=0){i--;j=10;}
  1773.       }
  1774.           else if(i==1&&opera[1][11]!=0&&save>11&&save<16)
  1775.       { save1=save;break; }                   // 连续计算时保存运算符
  1776.       else if(save==11&&opera[1][11]==0) continue;// 操作数1为0时不理会
  1777.           else if(save==11&&opera[1][11]!=0)  break;
  1778.           else if((i==0||i==1&&j==1)&&save>11&&save<16){i=0; break;}   
  1779.        // 当操作数0由运算符结束输入,再按符号键更改
  1780.           else continue;
  1781.     }
  1782.     if(opera[i][10]>opera[i][11]||opera[i][10]==0)
  1783.       opera[i][10]=opera[i][11]+1;        // 整数时小数位保存到最后
  1784.     while(opera[i][11]>=opera[i][10]&&opera[i][opera[i][11]]==0)
  1785.       opera[i][11]--;                                // 去除小数点后多余的0
  1786.     if(i==0)
  1787.     {
  1788.       opera[1][0]=save;                        // 保存运算符并显示
  1789.       display_cnasc(0x88,1,tool_cal[save-12]);
  1790.     }
  1791.     if(opera[0][11]==0) display_cnasc(0x95,1," 0");
  1792.     j=1;
  1793.     while(j<=opera[i][11]&&opera[i][j]==0) j++;//判断是否操作数是否全为0
  1794.     j--;
  1795.     if(j==opera[i][11]) opera[i][11]=0;
  1796.     j=1;
  1797.   }
  1798.   return 1;
  1799. }


  1800. /****************************************************************************************
  1801. 功能:  乘法运算
  1802. 描述:  结果由右到左保存
  1803. 参数:  i , j , opera[i][j],p,q,r,k,save1
  1804. 返回值:1(成功),0(结果位0),-1(溢出)
  1805. /****************************************************************************************/

  1806. char multiplication()
  1807. {
  1808.   uchar p,q,r,k,save1=0; // p指向操作数0 ,q指向操作数1,r指向结果
  1809.   if(opera[0][11]==0||opera[1][11]==0) return 0;
  1810.   resu[10]=opera[0][11]+opera[1][11]-opera[0][10]-opera[1][10]+2; // RESU记录小数点后的位数
  1811.   q=opera[1][11];                                        // 记录操1的位数
  1812.   r=9;
  1813.   opera[1][11]=1;
  1814.   k=1;
  1815.   while(opera[1][k]==0) {opera[1][11]=opera[1][11]+1;k++;}        // 去除前端的0
  1816.   k=1;
  1817.   while(opera[0][k]==0) k++;                        // 去除前端的0
  1818.   resu[11]=9;
  1819.   for(resu[0]=9;q>=opera[1][11];q--,resu[0]--)
  1820.   {
  1821.     if(opera[1][q]==0) continue;                // 操1此位数为0时直接比较
  1822.     for(p=opera[0][11],r=resu[0];p>=k;p--)
  1823.     {
  1824.       save1=opera[0][p]*opera[1][q];                // 将相乘后的数保存
  1825.       resu[r]+=(save1%10);//将缓存中的数取余后加到结果中R指向的位
  1826.       save1/=10;
  1827.       save1=save1+(resu[r]/10);                        // 保存进位的数
  1828.       resu[r]%=10;                                        // 重新写入
  1829.           if(r==1)        //结果有溢出时移位
  1830.           {
  1831.             if(save1==0&&p==k) break;        // 计算到最后位且没进位跳出
  1832.             else if(resu[10]>0)                // 要求有小数存在
  1833.         {
  1834.               for(r=9;r>1;r--) resu[r]=resu[r-1];
  1835.               r=1;
  1836.           resu[r]=save1;
  1837.               resu[11]=1;
  1838.               resu[10]--;
  1839.               resu[0]++;
  1840.         }   
  1841.             else   return -1;                         // 否则溢出
  1842.           }
  1843.           if(r>1&&(r-1)<resu[11])                        // 保存结果位的最高位
  1844.           {
  1845.             if(save1!=0) resu[11]=r-1;
  1846.             else resu[11]=r;
  1847.           }
  1848.           if(r>1){ r--;resu[r]+=save1;}// 当R为1时只需要移位记录结果
  1849.     }
  1850.   }
  1851.   while(resu[resu[11]]==0) resu[11]++;         // 去除前端的0
  1852.   resu[0]=opera[0][0];                                // 保存符号位
  1853.   removal_data(0,1);                                        // 清数据不清显示
  1854.   if(resu[10]>8)   //如果小数点后的数有9 位或以上时,需后移到使小数点放到2的位置  
  1855.   {
  1856.     save1=resu[10]-10+resu[11];                 // 记录后移位数
  1857.     if(save1>7)  return 0;          //当后移的数大于有效数字的位数时结果为0
  1858.     else         // 否则按需移位
  1859.     {
  1860.       for(p=save1+2,r=resu[11];p<10;p++,r++) opera[0][p]=resu[r];
  1861.           opera[0][10]=2;opera[0][11]=9;opera[0][0]=resu[0];
  1862.     }                // 因有效数小于小数点后的数,所以首位为0  
  1863.   }        
  1864.   else          //如果小数点后的数在8位以内时分两种情况
  1865.   {        
  1866.     opera[0][0]=resu[0];  
  1867.     save1=10-resu[11];         // 记录有效位数
  1868.     if(resu[10]>=save1)         // 小数的在有效数字的左边
  1869.     {        
  1870.           for(p=resu[10]+1,r=9;r>=resu[11];p--,r--)
  1871.         opera[0][p]=resu[r];        // 从小数点的最后一位开始
  1872.       opera[0][10]=2;opera[0][11]=resu[10]+1;
  1873.     }
  1874.     else                                  // 小数点在有效数字内
  1875.     {  
  1876.           for(p=1,r=resu[11];r<10;p++,r++) opera[0][p]=resu[r];
  1877.             opera[0][11]=10-resu[11];
  1878.           if(resu[10]==0) opera[0][10]=opera[0][11]+1;
  1879.           else opera[0][10]=opera[0][11]-resu[10]+1;
  1880.     }
  1881.   }
  1882.   while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0)
  1883.     opera[0][11]--;          // 去除小数点后多余的0
  1884.   return 1;
  1885. }


  1886. /****************************************************************************************
  1887. 功能:  除法运算
  1888. 描述:  结果由左到右保存
  1889. 参数:  i , j , opera[i][j]
  1890. p,q,r, remainde, divisor, decimal
  1891. 返回值:1(成功),0(结果位0),-1(溢出)
  1892. *****************************************************************************************/

  1893. char divider()
  1894. {
  1895.   unsigned long int divisor=0,remainder=0;
  1896.   uchar p,q,r;
  1897.   char decimal=0;
  1898.   if(opera[1][11]==0) return -1;
  1899.   if(opera[0][11]==0) return 0;
  1900.   for(r=1;r<12;r++)                // 判断两数是否相等
  1901.   {
  1902.     if(opera[0][r]!=opera[1][r]) break;
  1903.   }
  1904.   if(r==12)
  1905.   {
  1906.     p=opera[0][0];
  1907.     removal_data(0,1);
  1908.     opera[0][0]=r;
  1909.     opera[0][1]=1;
  1910.     opera[0][10]=2;
  1911.     opera[0][11]=1;
  1912.     return 1;
  1913.   }  
  1914.   decimal=(opera[0][11]-opera[0][10])-(opera[1][11]-opera[1][10]);
  1915.   // 记录两操作数小数点后位数的差
  1916.   if(decimal>0)                // 若操0大于操1时重新记录小数点的位置
  1917.   {
  1918.     opera[0][10]=opera[0][11]-decimal+1;
  1919.     resu[10]=opera[0][10];
  1920.   }
  1921.   else          // 否则小数点后没有数,记录有效数的位数
  1922.   {        
  1923.     opera[0][11]-=decimal;
  1924.     opera[0][10]=opera[0][11]+1;
  1925.     resu[10]=opera[0][10];
  1926.   }
  1927.   q=1;
  1928.   divisor=0;
  1929.   while(q<=opera[1][11]) // 将操1的数整形化
  1930.   {
  1931.     divisor=divisor*10+opera[1][q];q++;
  1932.   }
  1933.   if(divisor==1)   
  1934.   {
  1935.     if(resu[10]>10)        return -1;
  1936.         else return 1;
  1937.   }
  1938.   r=1;p=1;
  1939.   remainder=(unsigned long int)opera[0][1]; // 先对余数寄存器附初值
  1940.   do
  1941.   {   
  1942.         if(r>9)  // 结果位已经到达最后1位
  1943.         {  
  1944.             if(resu[1]==0&&resu[10]!=2) // 判断是否有得移位
  1945.           {         
  1946.             for(r=1;r<9;r++) resu[r]=resu[r+1];        
  1947.             resu[9]=0;
  1948.             if(resu[10]!=0) resu[10]--;
  1949.             r=9;
  1950.           }
  1951.       else if(p>=opera[0][11]||p>=opera[0][10])  break; // 如果计算到最后一位,或者有小数点存在时结束
  1952.       else return -1; // 否则错误
  1953.         }
  1954.         resu[r]=(uchar)(remainder/divisor);        // 保存结果
  1955.     remainder=(remainder%divisor);                // 重新写入余数
  1956.         p++;r++;         
  1957.     if(p>opera[0][11]&&remainder==0) break; // 除尽后跳出
  1958.     else if(p<=opera[0][11]&&p<10)                // 余数*10后加后一位
  1959.       {remainder=remainder*10+opera[0][p];}
  1960.     else   remainder=remainder*10;         //超出后余数*10
  1961.   }while(1);
  1962.   resu[11]=r-1;
  1963.   resu[0]=opera[0][0];
  1964.   removal_data(0,1);
  1965.   r=1;   
  1966.   while(resu[r]==0&&resu[10]!=(r+1)&&r<resu[11]) r++;
  1967. //去除结果前端的0
  1968.   if(r==resu[11]) return 0;
  1969.   resu[10]=resu[10]-r+1;
  1970.   p=1;
  1971.   while(r<=resu[11]){opera[0][p]=resu[r];r++;p++;}
  1972.   opera[0][0]=resu[0];opera[0][10]=resu[10];opera[0][11]=p-1;
  1973.   while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0)
  1974.     opera[0][11]--;
  1975.   return 1;
  1976. }


  1977. /****************************************************************************************
  1978. 功能:  加法运算
  1979. 描述:  以小数点位中心两边相加
  1980. 参数:  i , j , opera[i][j],p,q,r
  1981. 返回值:1(成功),0(结果位0),-1(溢出)
  1982. /****************************************************************************************/

  1983. char adder()
  1984. {
  1985.   uchar p,q,r;
  1986.   if(opera[0][11]==0&&opera[1][11]==0)   return 0;
  1987.   else if(opera[0][11]==0)
  1988.     {for(q=0;q<12;q++) opera[0][q]=opera[1][q];return 1;}
  1989.   else if(opera[1][11]==0) return 1;
  1990.   else
  1991.   {
  1992.     p=opera[0][10]-1;
  1993.     q=opera[1][10]-1;
  1994.     p>q?(r=p):(r=q);
  1995.     resu[10]=r+1;                // 小数点位保存
  1996.     resu[0]=opera[0][0];        // 保存符号位
  1997.     while(r>0)                        // 将小数点前的数相应相加后放到结果中
  1998.     {
  1999.       if(p>0&&q>0){resu[r]=opera[0][p]+opera[1][q];p--;q--;}
  2000.       else if(p>0&&q==0){resu[r]=opera[0][p];p--;}
  2001.       else        {resu[r]=opera[1][q];q--;}
  2002.       r--;
  2003.     }
  2004.     r=resu[10];
  2005.     p=opera[0][10];
  2006.     q=opera[1][10];
  2007.     while(r<10)                        // 将小数点后的数放到结果中
  2008.     {
  2009.       if(p>opera[0][11]&&q>opera[1][11]) break;
  2010.       else if(p<=opera[0][11]&&q<=opera[1][11])
  2011.         {resu[r]=opera[0][p]+opera[1][q];p++;q++;}
  2012.       else if(p<=opera[0][11]&&q>opera[1][11])
  2013.         {resu[r]=opera[0][p];p++;}
  2014.       else        {resu[r]=opera[1][q];q++;}
  2015.       r++;
  2016.     }
  2017.     r--;
  2018.     resu[11]=r;
  2019.     p=0;
  2020.     while(r>0)                        // 由右到左将大于9的数进位
  2021.     {
  2022.       resu[r]+=p;                        // p为进位标记
  2023.       p=0;
  2024.       if(resu[r]>9) {resu[r]-=10;p=1;}
  2025.       r--;
  2026.     }
  2027.     if(p==1)                                // 溢出移位
  2028.     {
  2029.       if(resu[10]==10) return -1;
  2030.       else {
  2031.         for(r=9;r>1;r--) resu[r]=resu[r-1];
  2032.         resu[1]=1;resu[10]++;}
  2033.     }
  2034.    removal_data(0,1);
  2035.    r=0;
  2036.    while(r<12){opera[0][r]=resu[r];r++;}
  2037.    while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0)
  2038.      opera[0][11]--;
  2039.    return 1;
  2040.   }
  2041. }

  2042. /****************************************************************************************
  2043. 功能:  减法运算
  2044. 描述:  先比较两操作数的大小用one ,two互换
  2045. 参数:  i , j , opera[i][j],p,q,r,one,two
  2046. 返回值:1(成功),0(结果位0),-1(溢出)
  2047. /****************************************************************************************/

  2048. char subtraction()
  2049. {
  2050.   uchar p,q,r,one,two;
  2051.   if(opera[0][11]==0&&opera[1][11]==0)   return 0;
  2052.   else if(opera[0][11]==0)
  2053.   {
  2054.     for(q=1;q<12;q++)
  2055.     opera[0][q]=opera[1][q];
  2056.         opera[0][0]=!opera[0][0];return 1;
  2057.   }
  2058.   else if(opera[1][11]==0) return 1;
  2059.   else
  2060.   { // 比较大小(大放到one)
  2061.     if(opera[0][10]>opera[1][10]){one=0;two=1;}
  2062.     else if(opera[1][10]>opera[0][10]) {one=1;two=0;}
  2063.     else
  2064.     {
  2065.       r=1;
  2066.           while(r<10&&opera[0][r]==opera[1][r]) r++;
  2067.           if(r==10) {removal_data(0,1);return 0;}
  2068.       opera[0][r]>opera[1][r]?(one=0,two=1):(one=1,two=0);
  2069.     }
  2070.     p=opera[one][10]-1;
  2071.     q=opera[two][10]-1;
  2072.     r=p;                        // 保存小数点前的数
  2073.     resu[10]=r+1;        // 保存小数点位
  2074.     resu[0]=0;                // 用作借位标记
  2075.     while(r>0)                // 小数点前相减
  2076.     {
  2077.       if(p>0&&q>0)
  2078.           {
  2079.             opera[two][q]+=resu[0];
  2080.         resu[0]=0;
  2081.         if(opera[one][p]>=opera[two][q])
  2082.           resu[r]=opera[one][p]-opera[two][q];
  2083.             else
  2084.             {
  2085.                   resu[0]=1;
  2086.                   resu[r]=10+opera[one][p]-opera[two][q];
  2087.             }
  2088.             p--;q--;
  2089.           }
  2090.           else
  2091.           {            
  2092.         if(opera[one][p]<resu[0])
  2093.           {resu[r]=10+opera[one][p]-resu[0];}
  2094.             else
  2095.                   {resu[r]=opera[one][p]-resu[0];resu[0]=0;p--;}
  2096.           }
  2097.       r--;
  2098.     }
  2099.     r=resu[10];
  2100.     p=opera[one][10];
  2101.     q=opera[two][10];
  2102.     while(r<10)                // 将小数点后的数放到结果中
  2103.     {
  2104.       if(p>opera[one][11]&&q>opera[two][11]) break;
  2105.       else if(p<=opera[one][11]&&q<=opera[two][11])
  2106.           {
  2107.         if(opera[one][p]>=opera[two][q])  resu[r]=opera[one][p]-opera[two][q];
  2108.             else
  2109.             {
  2110.               resu[r]=10+opera[one][p]-opera[two][q];
  2111.               resu[0]=r;
  2112.               for(r-=1;r>0;r--) // 向前借位
  2113.                   {
  2114.                 if(resu[r]==0) resu[r]=9;
  2115.                     else{resu[r]-=1;break;}
  2116.                   }
  2117.                   r=resu[0];        
  2118.             }
  2119.             p++;q++;
  2120.           }                                            
  2121.       else if(p<=opera[one][11]&&q>opera[two][11])
  2122.         {resu[r]=opera[one][p];p++;}
  2123.       else        
  2124.           {
  2125.             resu[r]=10-opera[two][q];  
  2126.             resu[0]=r;
  2127.             for(r-=1;r>0;r--)
  2128.         {
  2129.                   if(resu[r]==0) resu[r]=9;
  2130.               else{ resu[r]-=1;break;}
  2131.                 }
  2132.             r=resu[0];
  2133.             q++;        
  2134.           }
  2135.       if(r==9)                 // 结果溢出移位
  2136.           {
  2137.             if(resu[1]==0&&resu[10]!=2)
  2138.         {
  2139.           for(r=1;r<9;r++) resu[r]=resu[r+1];
  2140.                   resu[10]--;resu[9]=0;r=8;
  2141.         }
  2142.           }
  2143.       r++;
  2144.     }
  2145.     r--;
  2146.     resu[11]=r;
  2147.     if(one==0)resu[0]=opera[0][0];        // 符号位写入
  2148.     else resu[0]=!opera[0][0];
  2149.     removal_data(0,1);
  2150.     r=1;
  2151.     while(resu[r]==0&&resu[10]!=(r+1)) r++; // 去除前端0
  2152.     resu[10]=resu[10]-r+1;                        // 重新写入小数点
  2153.     p=1;
  2154.     while(r<=resu[11]){opera[0][p]=resu[r];r++;p++;}
  2155.     opera[0][0]=resu[0];opera[0][10]=resu[10];opera[0][11]=p-1;
  2156.     while(opera[0][11]>=opera[0][10]&&opera[0][opera[0][11]]==0) opera[0][11]--;
  2157.     return 1;
  2158.   }
  2159. }


  2160. /****************************************************************************************
  2161. 功能:  计算器主函数
  2162. 描述:  根据符号位,运算符调用函数
  2163. 参数:  state,save
  2164. 返回值:无
  2165. ****************************************************************************************/


  2166. void calculator(void)
  2167. {
  2168.   char data state;
  2169.   uchar data save;
  2170.   save1=0;
  2171.   dis_title_e();
  2172.   display_cnasc(0x82,3,tool_menu[0]);
  2173.   display_cnasc(0x96,2,"等于");
  2174.   display_cnasc(0x8e,2,"删除");
  2175.   display_cnasc(0x9e,2,"退出");
  2176.   removal_data(2,0);         // 0为清除显示
  2177.   removal_data(0,0);
  2178.   i=0;j=1;
  2179.   while(1)
  2180.   {        
  2181.     cal_run=0;
  2182.     state=input_data();
  2183.     if(state==1)  // 根据opera[1][0]的数值调用程序
  2184.     {
  2185.       if(opera[1][0]==12&&opera[0][0]==0||opera[1][0]==13&&opera[0][0]==1)
  2186.             state=adder();
  2187.       else if(opera[1][0]==12&&opera[0][0]==1||opera[1][0]==13&&opera[0][0]==0)
  2188.             state=subtraction();
  2189.       else if(opera[1][0]==14) state=multiplication();
  2190.       else state=divider();
  2191.     }
  2192.         if(state==0)  return;
  2193.     i=0;j=1;
  2194.     cal_run=1;
  2195.     switch(state)
  2196.     {
  2197.       case -1:                                                 // 结果溢出
  2198.                   removal_data(2,0);
  2199.               removal_data(0,0);  
  2200.                       display_cnasc(0x8a,3,"溢出!!");
  2201.                       save1=0;
  2202.                           break;
  2203.       case  0:                                                // 结果为零
  2204.                           if(save1==0)
  2205.                           {
  2206.                             removal_data(2,1);
  2207.                                 removal_data(0,1);
  2208.                             display_cnasc(0x98,1,"= ");
  2209.                             display_cnasc(0x9d,1," 0");
  2210.                           }
  2211.                           break;                                // 结果显示
  2212.       case  1:
  2213.                           if(save1==0)
  2214.                           {
  2215.                             cal_run=1;
  2216.                             display_cnasc(0x98,1,"= ");
  2217.                 dis_cdata(0x98);
  2218.                           }
  2219.                           break;
  2220.     }
  2221.         if(save1==0) save=gotkey();         // save1记录连续计算符
  2222.         cal_run=0;        
  2223.         if((save>11&&save<16&&state==1)||save1!=0)
  2224.         {
  2225.           removal_data(2,0);
  2226.           removal_data(1,0);
  2227.           display_cnasc(0x90,6,"               ");
  2228.           if(opera[0][11]==0) display_cnasc(0x95,1," 0");
  2229.           else dis_cdata(0x90);
  2230.           if(save1!=0)save=save1;
  2231.           save1=0;
  2232.           display_cnasc(0x88,1,tool_cal[save-12]);
  2233.           opera[1][0]=save;
  2234.           i=1;j=1;
  2235.         }
  2236.         else if(save>=0&&save<10&&state==1)
  2237.         {
  2238.           removal_data(2,0);
  2239.           removal_data(0,0);
  2240.           opera[0][1]=save;
  2241.           opera[0][11]++;
  2242.           dis_cdata(0x90);
  2243.           i=0;j=2;
  2244.         }
  2245.         else if(save==10)
  2246.         {  
  2247.           removal_data(2,0);
  2248.           removal_data(0,0);
  2249.       opera[i][10]=2;
  2250.           opera[i][11]=1;
  2251.       j=2;
  2252.         }
  2253.         else
  2254.         {
  2255.           removal_data(2,0);
  2256.           removal_data(0,0);
  2257.         }
  2258.   }                                                                                       
  2259. }
  2260.   

  2261. /*=====================================================================================
  2262. 函数名称:温度功能
  2263. 功能描述:连续检查温度
  2264. 全局变量:temprun  oth_run  als_temp  adju_si
  2265. 参数说明:见函数
  2266. 返回说明:无
  2267. 设 计 人:LIJH
  2268. 版    本:1.0
  2269. 说    明:
  2270. ======================================================================================*/


  2271. /*温度显示*/
  2272. uchar temp_func_dis(void)
  2273. {
  2274.   uchar save[2],k;
  2275.   clear_dis();
  2276.   dis_title_e();
  2277.   display_cnasc(0x82,3,"温度计");  
  2278.   display_cnasc(0x98,3,"设定");
  2279.   display_cnasc(0x9e,3,"退出");
  2280.   display_cnasc(0x8e,1," \x1f");
  2281.   num2_asc_dis(10,0x85);
  2282.   temprun=1;
  2283.   while(1)
  2284.   {
  2285.         if(ds18b20)
  2286.     {
  2287.       if(temp.t_data[0]>99)          // 温度值大于99时
  2288.           {
  2289.             save[0]=temp.t_data[0]/100;
  2290.         save[1]=(temp.t_data[0]/10)%10;
  2291.         num2_asc_dis(save[0],0x80);
  2292.             num2_asc_dis(save[1],0x81);
  2293.             save[0]=char_num[temp.t_data[0]%10];
  2294.             num2_asc_dis(save[0],0x82);
  2295.       }
  2296.           else                                         // 温度小于100
  2297.           {
  2298.         con_disp(0x00,0x00,0x80,0x90,1,16);
  2299.                 con_disp(0x00,0x00,0x88,0x90,1,16);
  2300.                 if(temp_pn) con_disp(0x3f,0xfc,0x80,0x9d,1,3);
  2301.             else  con_disp(0x00,0x00,0x80,0x9d,1,3);
  2302.             save[0]=temp.t_data[0]/10;
  2303.             save[1]=temp.t_data[0]%10;
  2304.             num2_asc_dis(save[0],0x81);
  2305.             num2_asc_dis(save[1],0x82);
  2306.           }
  2307.           save[0]='.';
  2308.           save[1]=char_num[temp.t_data[1]/10];
  2309.           display_cnasc(0x8b,1,save);
  2310.           save[0]=char_num[temp.t_data[1]%10];
  2311.           if(save[0]=='1') save[1]='2';                   // 补偿精度
  2312.           else if(save[0]=='7') save[1]='5';
  2313.           else if(save[0]=='8'||save[0]=='1') save[1]='7';
  2314.           else save[1]='0';
  2315.           display_cnasc(0x8c,1,save);
  2316.     }
  2317.         else
  2318.         {
  2319.       clear_dis();
  2320.       display_cnasc(0x92,4,"没有发现");
  2321.       display_cnasc(0x8c,4,"温感器!");
  2322.           delay_pw();
  2323.           temprun=0;
  2324.           return 0;
  2325.         }
  2326.         k=gotkey();
  2327.         if(k==2)         // 进入设置菜单
  2328.         {
  2329.           display_cnasc(0x8e,1," \x04");
  2330.           delay(35000);
  2331.           display_cnasc(0x8e,1," \x1e");
  2332.           display_cnasc(0x9a,4,"\x11 (ok) \x10");
  2333.           return 1;
  2334.         }
  2335.   }
  2336. }

  2337. /*警报温度设置*/
  2338. uchar temp_func_set(void)
  2339. {
  2340.   uchar save[2];
  2341.   temprun=0;
  2342.   oth_run=0;
  2343.   rds1302_data();
  2344.   while(1)
  2345.   {  
  2346.         if(oth_run)
  2347.         {
  2348.           con_disp (0x00,0x00,0x88,0x90,2,16);
  2349.           con_disp (0xff,0xff,0x8e,0x90,2,16);
  2350.         }
  2351.         else
  2352.         {
  2353.           con_disp (0xff,0xff,0x88,0x90,2,16);
  2354.           con_disp (0x00,0x00,0x8e,0x90,2,16);
  2355.         }        
  2356.         save[0]=gotkey();
  2357.         if(save[0]==1||save[0]==3) oth_run=!oth_run;
  2358.         if(save[0]==5) return 1;
  2359.         if(save[0]==11)
  2360.         {  
  2361.           if(oth_run) return 0;
  2362.           else  
  2363.           {
  2364.                 clear_dis();
  2365.                 dis_title_e();
  2366.                 save[1]=save[0]=0;
  2367.                 oth_run=0;
  2368.             dis_title_e();
  2369.         display_cnasc(0x82,3,"设  定");
  2370.             display_cnasc(0x90,5,"警报温度:");
  2371.                 display_cnasc(0x88,7,"高于【    】℃");
  2372.                 display_cnasc(0x98,8,"低于【    】℃ \x10");
  2373.                 while(1)
  2374.                 {
  2375.                   if(save[1]==2) con_disp(0x00,0x00,index_temp_set[save[1]].lnum,index_temp_set[save[1]].rnum,2,13);
  2376.                   else con_disp(0x00,0x00,index_temp_set[save[1]].lnum,index_temp_set[save[1]].rnum,2,13);
  2377.                   if(save[0]==2) con_disp(0x0f,0xff,index_temp_set[save[0]].lnum,index_temp_set[save[0]].rnum,1,13);
  2378.           else con_disp(0xff,0xff,index_temp_set[save[0]].lnum,index_temp_set[save[0]].rnum,2,13);
  2379.               save[1]=save[0];
  2380.           adju_si=0;
  2381.                   oth_run=0;
  2382.                   while(1)
  2383.                   {
  2384.                     for(i=0;i<2;i++)
  2385.                     {
  2386.                       j=0x8b+i*16;
  2387.                           if(als_temp[i]==255) display_cnasc(j,2," off"); // 255值为关闭值
  2388.                       else
  2389.                           {
  2390.                             save1=save[1];
  2391.                             if(als_temp[i]>127)         // 当数值大于127时温度值为负数
  2392.                             {
  2393.                                   display_cnasc(j,1,"- ");
  2394.                                   save[0]=char_num[(als_temp[i]-128)/10];
  2395.                                   save[1]=char_num[(als_temp[i]-128)%10];
  2396.                                   display_cnasc(j+1,1,save);
  2397.                             }
  2398.                             else
  2399.                             {
  2400.                                   save[0]=' ';
  2401.                                   save[1]=char_num[als_temp[i]/100];
  2402.                                   if(save[1]=='0') save[1]=' ';
  2403.                                   display_cnasc(j,1,save);
  2404.                                   save[0]=char_num[als_temp[i]/10%10];
  2405.                                   save[1]=char_num[als_temp[i]%10];
  2406.                                   display_cnasc(j+1,1,save);
  2407.                             }
  2408.                             save[1]=save1;
  2409.                           }
  2410.                     }               
  2411.                         save[0]=gotkey();
  2412.                         do                   // 输入符号等待数值输入或下一位
  2413.                         {
  2414.                           if(save[0]==13){ oth_run=1;display_cnasc(0x8b+save[1]*16,2,"-   ");}
  2415.                           else if(save[0]==12){ oth_run=0;display_cnasc(0x8b+save[1]*16,2,"    ");}
  2416.                           else break;
  2417.                           save[0]=gotkey();
  2418.                           if(save[0]>=0&&save[0]<10||save[0]==11) break;
  2419.                         }while(1);
  2420.                         if(save[0]==14){ als_temp[save[1]]=255;}  // 乘号直接将警报温度关闭
  2421.                         if(save[0]>=0&&save[0]<10&&save[1]<2)
  2422.                     {
  2423.                           if(adju_si)
  2424.                       {
  2425.                             adju_si=0;
  2426.                             if(oth_run) als_temp[save[1]]&=0x7f;  // 消去符号位
  2427.                                 if(als_temp[save[1]]>24&&!oth_run) als_temp[save[1]]=240;
  2428.                         else als_temp[save[1]]=als_temp[save[1]]*10+save[0];
  2429.                                 if(oth_run&&als_temp[save[1]]>50) als_temp[save[1]]=50;                 
  2430.                                 if(!oth_run&&als_temp[save[1]]>120) als_temp[save[1]]=120;
  2431.                                 if(!oth_run&&als_temp[save[1]]<100) adju_si=1;        // 根据数值打开连写
  2432.                                 if(oth_run&&als_temp[save[1]]<10)  adju_si=1;
  2433.                           }
  2434.                           else
  2435.                           {
  2436.                             als_temp[save[1]]=save[0];
  2437.                                 adju_si=1;
  2438.                           }
  2439.                           if(oth_run) als_temp[save[1]]=als_temp[save[1]]|0x80;         // 写入符号
  2440.                           else als_temp[save[1]]=als_temp[save[1]]&0x7f;
  2441.                         }                        
  2442.                         if(save[0]==11)
  2443.                         {
  2444.                           if(als_temp[1]!=255&&als_temp[0]!=255)           // 上下限温度调整
  2445.                           {
  2446.                              if(save[1]==0&&als_temp[0]<als_temp[1]){als_temp[0]=als_temp[1];}
  2447.                             if(save[1]==1&&als_temp[1]>als_temp[0]){als_temp[1]=als_temp[0];}
  2448.                           }
  2449.                           save[0]=save[1]+1;adju_si=0;break;}
  2450.                 if(save[0]==10&&save[1]!=0) {save[0]=save[1]-1;adju_si=0;break;}
  2451.                   }
  2452.                   oth_run=0;
  2453.                   if(save[0]==3&&save[1]==2) break;
  2454.                 }
  2455.                 save_y_or_n();
  2456.                 if(oth_run)
  2457.                 {
  2458.                   wds1302_data(d02_temp,als_temp[0]);
  2459.                   wds1302_data(d02_temp+2,als_temp[1]);
  2460.                 }
  2461.                 return 1;
  2462.           }
  2463.         }
  2464.   }
  2465. }                  
  2466.                                  
  2467.                  
  2468. /*温度计主函数*/                 
  2469. void temp_func(void)
  2470. {                 
  2471.   uchar t;        
  2472.   while(1)
  2473.   {
  2474.     oth_run=1;
  2475.         t=temp_func_dis();
  2476.     if(t==1)
  2477.         {
  2478.           t=temp_func_set();
  2479.           if(t==0) return;
  2480.         }
  2481.     else return;
  2482.   }
  2483. }
  2484. /*=====================================================================================
  2485. 函数名称:闹铃功能
  2486. 功能描述:设定闹铃
  2487. 全局变量:alarm_time adju_si
  2488. 说    明:
  2489. ======================================================================================*/


  2490. void alarm_func(void)
  2491. {
  2492.   uchar save[2],a,d;
  2493.   clear_dis();
  2494.   dis_title_e();
  2495.   display_cnasc(0x82,3,"闹  钟");  
  2496.   display_cnasc(0x91,6,"状态:\x11    \x10");
  2497.   display_cnasc(0x89,3,"闹铃:");
  2498.   display_cnasc(0x9f,1,"→");
  2499.   display_cnasc(0x90,1,"『");
  2500.   display_cnasc(0x8f,1,"』");
  2501.   adju_si=0;
  2502.   a=0;d=0;
  2503.   save[0]=char_num[alarm_time[0]>>4];
  2504.   save[1]=char_num[alarm_time[0]&0x0f];
  2505.   display_cnasc(0x8c,1,save);
  2506.   display_cnasc(0x8d,1,": ");
  2507.   save[0]=char_num[alarm_time[1]>>4];
  2508.   save[1]=char_num[alarm_time[1]&0x0f];        
  2509.   display_cnasc(0x8e,1,save);
  2510.   do
  2511.   {
  2512.     if(a==0)
  2513.         {   
  2514.           display_cnasc(0x95,1,alm_sign[alm]);
  2515.       display_cnasc(0x94,1,"\x11 ");
  2516.       display_cnasc(0x96,1," \x10");
  2517.           con_disp(0x00,0x00,index_alm[d-1].lnum,index_alm[d-1].rnum,1,14);
  2518.         }
  2519.     if(a>0&&a<4)
  2520.         {
  2521.           if(d==0)
  2522.           {
  2523.                 display_cnasc(0x94,1,"  ");
  2524.         display_cnasc(0x96,1,"  ");
  2525.           }
  2526.           else
  2527.            con_disp(0x00,0x00,index_alm[d-1].lnum,index_alm[d-1].rnum,1,14);
  2528.          con_disp(0xff,0xff,index_alm[a-1].lnum,index_alm[a-1].rnum,1,14);        
  2529.     }                  
  2530.         d=a;
  2531.         while(1)
  2532.         {
  2533.           a=gotkey();
  2534.           if((a==1||a==3)&&d==0)
  2535.           {
  2536.             alm=!alm;
  2537.                 if(a==1) display_cnasc(0x94,1,"\x09 ");
  2538.                 else display_cnasc(0x96,1," \x09");
  2539.                 delay(35000);
  2540.                 if(a==1) display_cnasc(0x94,1,"\x11 ");
  2541.         else display_cnasc(0x96,1," \x10");
  2542.                 display_cnasc(0x95,1,alm_sign[alm]);
  2543.           }
  2544.           if(d>0&&d<3&&a>=0&&a<10)
  2545.           {
  2546.             if(adju_si)
  2547.                 {
  2548.                   alarm_time[d-1]<<=4;alarm_time[d-1]+=a;
  2549.                   if(d==1&&alarm_time[0]>0x23) alarm_time[0]=a;
  2550.                   else if(d==2&&alarm_time[1]>0x59) alarm_time[1]=a;
  2551.                   else adju_si=0;
  2552.                 }
  2553.             else  
  2554.                 {
  2555.                   alarm_time[d-1]=a;adju_si=1;
  2556.                 }
  2557.                 save[0]=char_num[alarm_time[d-1]>>4];
  2558.             save[1]=char_num[alarm_time[d-1]&0x0f];
  2559.             display_cnasc(0x8c+(d-1)*2,1,save);
  2560.           }
  2561.           if(a==11){a=d+1;break;}
  2562.           if(a==10&&d!=0){a=d-1;break;}
  2563.         }
  2564.         adju_si=0;
  2565.         if(a==4)
  2566.         {
  2567.           save_y_or_n();
  2568.           wds1302_data(d02_signs,signs);
  2569.           wds1302_data(d02_alm,alarm_time[0]);
  2570.           wds1302_data(d02_alm+2,alarm_time[1]);
  2571.           return;
  2572.         }
  2573.   }while(1);
  2574. }



  2575. /*=====================================================================================
  2576. 函数名称:篮球器功能
  2577. 功能描述:分数  时间  24秒  
  2578. 全局变量:resu  opera
  2579. 参数说明:见函数
  2580. 返回说明:无
  2581. 设 计 人:LIJH
  2582. 版    本:1.0
  2583. 说    明:
  2584. ======================================================================================*/

  2585. /*比赛设置*/
  2586. void nba_set(void)
  2587. {
  2588.   uchar nba,save1,key,save[2];
  2589.   clear_dis();
  2590.   dis_title_e();
  2591.   if(resu[7]==1) display_cnasc(0x82,3,"加  时");
  2592.   else  
  2593.   {
  2594.     display_cnasc(0x82,3,"设  定");
  2595.     opera[0][0]=0;
  2596.     opera[1][0]=1;
  2597.   }
  2598.   resu[6]=0;        // 赋初值
  2599.   resu[0]=1;
  2600.   resu[1]=4;
  2601.   resu[2]=12;
  2602.   resu[3]=0;
  2603.   resu[4]=24;
  2604.   display_cnasc(0x90,7,"队1:红  队2:白");
  2605.   display_cnasc(0x88,7,"24秒:Y  节数:4");
  2606.   display_cnasc(0x98,8,"每节时间: 12分钟");
  2607.   save1=0;nba=0;
  2608.   while(1)
  2609.   {
  2610.     if(save1==4) display_cnasc(0x9c,1,":");
  2611.         else display_cnasc(index_nba[save1],1,"  ");
  2612.         if(nba==4)  display_cnasc(0x9c,1,":\x10");
  2613.         else display_cnasc(index_nba[nba],1,"\x11 ");
  2614.         save1=nba;
  2615.         key=gotkey();        
  2616.         if(key==1||key==3)
  2617.         {         
  2618.           switch(nba)     // 导航更改数据
  2619.           {
  2620.             case 0:                           
  2621.                 case 1:
  2622.                         if(key==1){if(opera[nba][0]>0) opera[nba][0]--;
  2623.                                            else opera[nba][0]=7;}
  2624.                                 if(key==3){if(opera[nba][0]<7) opera[nba][0]++;
  2625.                                            else opera[nba][0]=0;}
  2626.                                 display_cnasc(index_nba[nba]-1,1,nba_oppo[opera[nba][0]]);
  2627.                                 break;
  2628.                 case 2:
  2629.                                 if(resu[0]>0) resu[0]=0;
  2630.                                 else resu[0]=1;
  2631.                                 if(resu[0]>0)         display_cnasc(0x8a,1,":Y");
  2632.                                 else display_cnasc(0x8a,1,":N");
  2633.                                 break;
  2634.                 case 3:
  2635.                                 if(key==1){if(resu[1]>1) resu[1]--;
  2636.                                             else  resu[1]=4;}
  2637.                             if(key==3){if(resu[1]<4) resu[1]++;
  2638.                                        else resu[1]=1;}
  2639.                                 save[0]=':';
  2640.                                 save[1]=char_num[resu[1]];
  2641.                                display_cnasc(0x8e,1,save);
  2642.                                 break;
  2643.                 case 4:
  2644.                                 if(key==1){if(resu[2]>0) resu[2]--;
  2645.                                             else  resu[2]=60;}
  2646.                             if(key==3){if(resu[2]<60) resu[2]++;
  2647.                                        else resu[2]=0;}
  2648.                                 save[0]=char_num[resu[2]/10];
  2649.                                 save[1]=char_num[resu[2]%10];
  2650.                                display_cnasc(0x9d,1,save);
  2651.                                 resu[5]=resu[2];
  2652.                                 break;
  2653.       }
  2654.         }
  2655.         if(key==11)
  2656.         {
  2657.           nba++; if(nba==5) return;                           
  2658.         }
  2659.         if(key==10&&nba!=0)  nba--;
  2660.   }
  2661. }



  2662. /*界面其他元素*/
  2663. void nba_oth_dis(void)
  2664. {
  2665.   uchar save[2];
  2666.   if(resu[7]==1) display_cnasc(0x80,5,"加时时间:");
  2667.   else display_cnasc(0x80,5,"比赛时间:");
  2668.   display_cnasc(0x98,1,nba_oppo[opera[0][0]]);
  2669.   display_cnasc(0x9e,1,nba_oppo[opera[1][0]]);
  2670.   display_cnasc(0x99,1,"队");
  2671.   display_cnasc(0x9f,1,"队");
  2672.   save[0]='0';
  2673.   save[1]=char_num[resu[6]+1];
  2674.   display_cnasc(0x9b,1,save);
  2675.   display_cnasc(0x9c,1,"st");
  2676.   con_disp(0xff,0xff,0x83,0x90,2,1); // 画正方框
  2677.   con_disp(0xff,0xff,0x8b,0x8f,2,1);
  2678.   con_disp(0x80,0x00,0x83,0x91,1,15);
  2679.   con_disp(0x00,0x01,0x84,0x91,1,15);
  2680.   con_disp(0x80,0x00,0x8b,0x80,1,15);
  2681.   con_disp(0x00,0x01,0x8c,0x80,1,15);
  2682.   nba_dis_time();
  2683.   if(resu[0]==0) display_cnasc(0x93,2,"\x07--\x07");
  2684.   display_cnasc(0x8b,2," S! ");
  2685. }



  2686. /*篮球器主函数*/
  2687. void nba_timer(void)
  2688. {
  2689.   uchar save,key,nba=0;
  2690.   als=di0=1;alm=keb=di1=oth_run=0;
  2691.   time_init();  
  2692.   display_cnasc(0x82,3,"篮球器");
  2693.   dis_title_e();
  2694.   removal_data(0,1);
  2695.   while(1)          // 使用说明
  2696.   {
  2697.         display_cnasc(0x90,8,timer_tips[nba]);
  2698.         display_cnasc(0x88,8,timer_tips[nba+1]);
  2699.         display_cnasc(0x98,8,timer_tips[nba+2]);
  2700.         key=gotkey();
  2701.         if(key==11)
  2702.         {
  2703.           nba+=3;
  2704.           if(nba>9) break;
  2705.         }
  2706.         if(key==10)
  2707.         {
  2708.           if(nba>0) nba-=3 ;
  2709.         }
  2710.   }
  2711. nn:
  2712.   nba_set();
  2713.   clear_dis();
  2714.   nba_oth_dis();
  2715.   nba_tim=1;
  2716.   while(1)
  2717.   {        
  2718.         for(save=0x80,nba=0;nba<2;nba++)
  2719.         {
  2720.           if(opera[nba][1]>99)        // 分数显示
  2721.           {
  2722.             num2_asc_dis(opera[nba][1]/100,save);
  2723.                 num2_asc_dis(opera[nba][1]/10%10,save+1);
  2724.                 num2_asc_dis(opera[nba][1]%10,save+2);
  2725.           }
  2726.           else
  2727.           {
  2728.                 num2_asc_dis(opera[nba][1]/10,save);
  2729.                 num2_asc_dis(opera[nba][1]%10,save+1);
  2730.       }
  2731.           if(opera[1][1]>99) save=0x85;
  2732.           else save=0x86;
  2733.         }
  2734.         
  2735.         do
  2736.         {
  2737.         key=gotkey();
  2738.   ss:
  2739.         switch(key)
  2740.         {
  2741.           case 12:
  2742.           case 13:
  2743.                    if(key==12)
  2744.                              {if(opera[0][1]<250) opera[0][1]++;}
  2745.                    else
  2746.                              {if(opera[0][1]>0) opera[0][1]--;}
  2747.                            save=110;
  2748.                             break;
  2749.           case 14:
  2750.           case 15:
  2751.                    if(key==14)
  2752.                              {if(opera[1][1]<250) opera[1][1]++;}
  2753.                    else
  2754.                              {if(opera[1][1]>0) opera[1][1]--;}
  2755.                            save=110;
  2756.                            break;
  2757.           case  7:
  2758.                    TR1=TR0=EA=0;
  2759.                    if((++resu[3])>59)
  2760.                    {
  2761.                      resu[3]=0;
  2762.                          if((++resu[2])>59)
  2763.                                  {
  2764.                                    resu[3]=0;
  2765.                                    if(++resu[2]>60) resu[2]=0;
  2766.                                  }
  2767.                            }
  2768.                        if(resu[4]<24) resu[4]++;
  2769.                            nba_dis_time();
  2770.                            break;
  2771.           case  8:
  2772.                    if(resu[0]==1)
  2773.                            {
  2774.                              TL1=(time_count&0x00FF);
  2775.                  TH1=(time_count>>8);
  2776.                              resu[4]=24; nba_dis_time();
  2777.                                  TR0=TR1=EA=1;
  2778.                            }
  2779.                            break;
  2780.           case  9:
  2781.                    if(resu[2]==0&&resu[3]==0)
  2782.                    {
  2783.                      resu[2]=resu[5];resu[4]=24;
  2784.                                  if(resu[6]==resu[1])
  2785.                                  {                                                          // 判断比分进行加时赛
  2786.                                    if(opera[0][1]==opera[1][1]){nba_tim=0;resu[7]=1; goto nn;}
  2787.                                    while(gotkey()!=10);                  // 否则只能退出
  2788.                                    signs=r1302(d02_signs+1);
  2789.                                    nba_tim=0;
  2790.                                    return;
  2791.                                  }
  2792.                                  else nba_oth_dis();
  2793.                                  break;
  2794.                    }
  2795.                            if(EA) {TR0=TR1=EA=0;break;}
  2796.                    if(!EA&resu[4]!=0){ EA=TR0=1;if(resu[0]==1) TR1=1;}
  2797.                            break;                                                                                                                 
  2798.           case 10:
  2799.           case 11:
  2800.                    if(!EA)                        // 暂停状态下 ok键两次返回时钟界面
  2801.                            {                //  ./s 键两次退出
  2802.                              delay(6000);
  2803.                                  save=gotkey();
  2804.                                  if(save==key)
  2805.                                  {
  2806.                                    if(key==11)
  2807.                                    {
  2808.                                      clear_dis();oth_run=1;
  2809.                                      rds1302_time();
  2810.                                          init_d2=1;
  2811.                                      dis_mode2();
  2812.                                          init_d2=0;
  2813.                                      while(gotkey()!=11);
  2814.                                      oth_run=0;
  2815.                                          save=110;
  2816.                                      clear_dis();
  2817.                                      nba_oth_dis();
  2818.                                    }
  2819.                                    else{ signs=r1302(d02_signs+1); nba_tim=0;return;}
  2820.                              }
  2821.                                  else{ key=save;goto ss;}
  2822.                            }
  2823.                            break;         
  2824.         }
  2825.         if(save==110)  break;
  2826.     }while(1);        
  2827.   }  
  2828. }

  2829.          
  2830. /*=====================================================================================
  2831. 函数名称:设置功能
  2832. 功能描述:系统状态设置  
  2833. 全局变量:signs
  2834. 参数说明:见函数
  2835. 返回说明:无
  2836. 设 计 人:LIJH
  2837. 版    本:1.0
  2838. 说    明:
  2839. ======================================================================================*/


  2840. /*设置调整内容 参数格式:选中设置项,设置项子值*/
  2841. uchar set_dis(uchar menu,uchar sub)
  2842. {
  2843.   uchar save;
  2844.   con_disp(0xff,0xff,0x8e,0x80,2,16);
  2845.   con_disp(0x00,0x00,0x8a,0x80,4,16);
  2846.   display_cnasc(0x96,1,"\x1e ");
  2847.   display_cnasc(0x9e,1,"\x1f ");
  2848.   display_cnasc(0x92,1,"  ");
  2849.   display_cnasc(0x9a,1,"  ");
  2850.   display_cnasc(0x8d,1,"\x11 ");
  2851.   display_cnasc(0x8a,1,"  ");
  2852.   while(1)
  2853.   {
  2854.    
  2855.     if(menu<2)
  2856.       display_cnasc(0x8e,2,set_bl_dm[menu][sub]);
  2857.     else
  2858.           display_cnasc(0x8e,2,set_mka[menu-2][sub]);
  2859.         save=gotkey();
  2860.         if(save==5)
  2861.         {
  2862.           key_dis(0x96);
  2863.           if(sub==0&&menu<2) sub=2;
  2864.           else if(sub==0&&menu>1) sub=1;
  2865.           else sub--;
  2866.     }
  2867.         if(save==2)
  2868.         {
  2869.           key_dis(0x9e);
  2870.           if(sub==2&&menu<2) sub=0;
  2871.           else if(sub==1&&menu>1) sub=0;
  2872.           else sub++;
  2873.         }
  2874.         if(save==1||save==11)
  2875.         {
  2876.           display_cnasc(0x8d,1,"\x04 ");
  2877.         delay(30000);
  2878.           con_disp(0x00,0x00,0x8e,0x80,2,16);
  2879.       con_disp(0xff,0xff,0x8a,0x80,4,16);
  2880.       display_cnasc(0x92,1,"\x1e ");
  2881.       display_cnasc(0x9a,1,"\x1f ");
  2882.       display_cnasc(0x96,1,"  ");
  2883.       display_cnasc(0x9e,1,"  ");
  2884.           display_cnasc(0x8a,1,"【");
  2885.           display_cnasc(0x8d,3,"】\x10 \x04 ");
  2886.           return(sub);          // 返回设置值
  2887.         }
  2888.   }
  2889. }


  2890. /*设置调整*/
  2891. void set_func(void)
  2892. {
  2893.   uchar d,key,save;
  2894.   display_cnasc(0x81,2,"设置");
  2895.   dis_title();
  2896.   display_cnasc(0x88,8,selected[1]);
  2897.   con_disp(0xff,0xff,0x8a,0x80,4,16);
  2898.   save=d=0;
  2899.   do
  2900.   {         
  2901.         display_cnasc(0x93,2,set_menu[index_s[save].lnum]);
  2902.         display_cnasc(0x8b,2,set_menu[save]);
  2903.         display_cnasc(0x9b,2,set_menu[index_s[save].rnum]);
  2904.         d=save;
  2905.         while(1)
  2906.         {
  2907.           key=gotkey();
  2908.           if(key==11||key==3){ enter_dis();break;}
  2909.           if(key==5){save=index_s[d].lnum;key_dis(0x92); break;}
  2910.           if(key==2){save=index_s[d].rnum;key_dis(0x9a); break;}
  2911.           if(key==1){ wds1302_data(d02_signs,signs); return;}
  2912.     }
  2913.         if(key==11||key==3)
  2914.         {
  2915.       save=0;
  2916.       for(key=0;key<2;key++)  //  进行两次比较 首次为现时值 其次为设定置更改
  2917.       {
  2918.         switch(d)
  2919.         {
  2920.           case 0:
  2921.                           if(key==1)
  2922.                           {
  2923.                                     bl0=bl1=0;
  2924.                                         if(save==1) bl0=1;
  2925.                                         if(save==2)        bl1=1;
  2926.                           }
  2927.                       else
  2928.                                   {if(bl0) save=1; if(bl1) save=2;}
  2929.                                   if(bl1) lcd_bl=close;
  2930.                                   else lcd_bl=open;
  2931.                               break;
  2932.               case 1:
  2933.                           if(key==1)
  2934.                           {
  2935.                                     di0=di1=0;
  2936.                                         if(save==1) di0=1;
  2937.                                         if(save==2)        di1=1;
  2938.                           }
  2939.                               else {if(di0) save=1; if(di1) save=2;}
  2940.                               break;
  2941.               case 2:
  2942.                           if(key==1) meu=(bit)save;
  2943.                       else {if(meu) save++;}              
  2944.                               break;
  2945.           case 3:
  2946.                           if(key==1) keb=(bit)save;
  2947.                       else{if(keb) save++;}              
  2948.                               break;
  2949.           case 4:
  2950.                           if(key==1) als=(bit)save;
  2951.                       else{if(als) save++;}              
  2952.                               break;
  2953.           case 5: wds1302_data(d02_signs,signs);
  2954.                       return;
  2955.         }
  2956.         if(key==0) save=set_dis(d,save);
  2957.       }
  2958.           save=d;
  2959.         }
  2960.   }while(1);
  2961. }


  2962. /*=====================================================================================
  2963. 函数名称:保密功能
  2964. 功能描述:系统重设  密码锁  密码更改  
  2965. 全局变量:resu  
  2966. 参数说明:见函数
  2967. 返回说明:无
  2968. 设 计 人:LIJH
  2969. 版    本:1.0
  2970. 说    明:
  2971. ======================================================================================*/


  2972. /*密码整理*/
  2973. void passwork_finish()
  2974. {
  2975.   uchar i;
  2976.   for(i=0;i<6;i+=2)
  2977.   {
  2978.     resu[i]<<=4;
  2979.         resu[i]+=resu[i+1];
  2980.   }
  2981. }



  2982. /*读取密码*/
  2983. uchar input_passwork()
  2984. {
  2985.   uchar i,save[2];
  2986.   save[0]=' ';
  2987.   display_cnasc(0x9d,3,"(./S)\x10");
  2988.   for(i=0;i<6;i++)
  2989.   {
  2990.     while(1)
  2991.         {
  2992.           resu[i]=gotkey();
  2993.           if(resu[i]>=0&&resu[i]<10) break;
  2994.           if(resu[i]==10) return 10;
  2995.         }
  2996.     save[1]=char_num[resu[i]];
  2997.         display_cnasc(0x89+i,1,save);
  2998.         delay(20000);
  2999.         display_cnasc(0x89+i,1," *");
  3000.   }
  3001.   return 11;
  3002. }



  3003. /*密码确认*/
  3004. void input_second_passwork()
  3005. {
  3006.   uchar i,save[2];
  3007.   save[0]=' ';
  3008.   display_cnasc(0x89,6,"            ");
  3009.   for(i=0;i<6;i++)
  3010.   {   
  3011.         if(resu[i]!=gotkey())        break;
  3012.         save[1]=char_num[resu[i]];
  3013.         display_cnasc(0x89+i,1,save);
  3014.         delay(20000);
  3015.         display_cnasc(0x89+i,1," *");
  3016.   }
  3017.   if(i!=6)
  3018.   {
  3019.     display_cnasc(0x89,6,"密码不相同!");
  3020.         delay(50000);
  3021.         display_cnasc(0x9a,6,"任意键 \x10    ");
  3022.         while(gotkey()==0xf0);
  3023.         return;
  3024.   }
  3025.   else
  3026.   {
  3027.         passwork_finish();
  3028.         for(i=0;i<6;i+=2)
  3029.           wds1302_data(d02_passw+i,resu[i]);
  3030.         for(i=0;i<6;i+=2)
  3031.           if(resu[i]!=r1302(d02_passw+i+1)) break;
  3032.         if(i==6)
  3033.          {display_cnasc(0x98,8,"\x10 更改成功!(OK) ");
  3034.           while(gotkey()!=11);return;}
  3035.         else
  3036.           display_cnasc(0x9a,6,"更改失败!  ");
  3037.   }
  3038.   delay_pw();
  3039. }                                



  3040. /*密码比较*/
  3041. uchar passwork_comp()
  3042. {
  3043.   uchar i;
  3044.   passwork_finish();
  3045.   for(i=0;i<6;i+=2)
  3046.         if(resu[i]!=r1302(d02_passw+i+1)) break;
  3047.   if(i==6)         return 1;
  3048.   else
  3049.   {
  3050.     display_cnasc(0x89,6,"  密码错误!");
  3051.         delay_pw();
  3052.         display_cnasc(0x89,6,"            ");
  3053.         return 110;
  3054.   }
  3055. }



  3056. /*保密导航*/
  3057. void passw_func(void)
  3058. {
  3059.   uchar save,d,key;
  3060.   d=0;save=0;
  3061.   do
  3062.   {
  3063.     clear_dis();
  3064.         display_cnasc(0x81,2,"保密");
  3065.     dis_title();
  3066.     display_cnasc(0x88,8,selected[0]);
  3067.     con_disp(0xff,0xff,0x8a,0x80,5,16);
  3068.     do
  3069.     {         
  3070.           display_cnasc(0x93,3,secrets_menu[index_p[save].lnum]);
  3071.           display_cnasc(0x8b,3,secrets_menu[save]);
  3072.           display_cnasc(0x9b,3,secrets_menu[index_p[save].rnum]);  
  3073.           d=save;
  3074.           while(1)
  3075.           {
  3076.             key=gotkey();
  3077.             if(key==11||key==3){enter_dis();break;}
  3078.             if(key==2){save=index_p[d].rnum; key_dis(0x9a);break;}
  3079.             if(key==5){save=index_p[d].lnum; key_dis(0x92);break;}
  3080.                 if(key==1){return;}
  3081.       }
  3082.       if(key==11||key==3)
  3083.           {        
  3084.                 if(d==3) return;               
  3085.                 clear_dis();
  3086.                 dis_title_e();
  3087.         switch(d)
  3088.         {
  3089.           case 0:
  3090.                           display_cnasc(0x82,3,"密码锁");
  3091.                                   display_cnasc(0x90,5,"输入密码:");
  3092.                                   while(1)
  3093.                                   {
  3094.                                     key=input_passwork();
  3095.                                     if(key==10) break;
  3096.                                     key=passwork_comp();
  3097.                                     if(key==1)
  3098.                             {
  3099.                                       display_cnasc(0x90,8,"处开启状态,按键");
  3100.                               display_cnasc(0x88,8,"□1-常开□2-关闭");
  3101.                                       display_cnasc(0x98,8,"■自动延时30秒  ");
  3102.                                           pw_oc=open;
  3103.                                       save1=i=0;   
  3104.                                       lock_op=1;   // 开启标记等待延时
  3105.                                       while(1)
  3106.                                       {
  3107.                                             key=gotkey(); // 返回255为延时时间到达
  3108.                                             if(key==255){ lock_op=0;pw_oc=close;break;}
  3109.                                             if(key==1)
  3110.                                             {
  3111.                                               display_cnasc(0x88,1,"■");
  3112.                                               display_cnasc(0x98,1,"□");
  3113.                                               lock_op=0;
  3114.                                             }
  3115.                                             if(key==2)
  3116.                                             {
  3117.                                               display_cnasc(0x88,1,"□");
  3118.                                                   display_cnasc(0x98,1,"□");
  3119.                                                   display_cnasc(0x8c,1,"■");
  3120.                                                   delay(60000);
  3121.                                                   clear_dis();
  3122.                                               dis_title_e();
  3123.                                   display_cnasc(0x82,3,"密码锁");
  3124.                                               display_cnasc(0x90,5,"密码锁将在");
  3125.                                                   display_cnasc(0x8a,6," 5秒后关闭:");
  3126.                                               for(save=0;save<5;save++)
  3127.                                               {
  3128.                                                 display_cnasc(0x99+save,1,"→");
  3129.                                                     delay_pw();
  3130.                                               }
  3131.                                                   display_cnasc(0x9e,1,"√");
  3132.                                                   pw_oc=open;
  3133.                                                   delay(30000);
  3134.                                                   pw_oc=close;
  3135.                                               lock_op=0;
  3136.                                               break;
  3137.                                             }
  3138.                                       }
  3139.                                           break;
  3140.                                     }
  3141.                                   }
  3142.                                break;
  3143.               case 1:
  3144.                           display_cnasc(0x82,3,"更  改");
  3145.                                   display_cnasc(0x90,6,"输入旧密码:");
  3146.                                   while(1)
  3147.                                   {
  3148.                                     key=input_passwork();
  3149.                                     if(key==10) break;
  3150.                                     key=passwork_comp();
  3151.                                     if(key==1)
  3152.                                     {
  3153.                                       display_cnasc(0x92,1,"新");
  3154.                                           display_cnasc(0x89,6,"            ");
  3155.                                       key=input_passwork();
  3156.                                           if(key==10) break;
  3157.                                           display_cnasc(0x90,6,"确认密码:  ");
  3158.                                           input_second_passwork();
  3159.                                           break;               
  3160.                                     }
  3161.                                   }
  3162.                                   break;
  3163.               case 2:
  3164.                           display_cnasc(0x82,3,"初始化");
  3165.                             display_cnasc(0x91,6,"是否初始化? ");
  3166.                   display_cnasc(0x89,6,"Y(OK)\\N(./S)");
  3167.                                   while(1)
  3168.                                   {
  3169.                                     key=gotkey();
  3170.                                         if(key==11)
  3171.                                         {
  3172.                                           clear_dis();
  3173.                                           dis_title_e();
  3174.                                           display_cnasc(0x82,3,"初始化");
  3175.                                           display_cnasc(0x90,5,"输入密码:");
  3176.                                           do
  3177.                                           {
  3178.                                             key=input_passwork();
  3179.                                             if(key==10) break;
  3180.                                             key=passwork_comp();
  3181.                                             if(key==1)
  3182.                                             {
  3183.                                                   display_cnasc(0x90,5,"密码正确!");
  3184.                                                   display_cnasc(0x89,7,"\x10 初始化中... ");
  3185.                                                   init_ds1302();
  3186.                                                   rds1302_data();
  3187.                                                   delay_pw();
  3188.                                                   display_cnasc(0x9a,6,"\x10 完成!(OK)");
  3189.                                                   while(gotkey()!=11);
  3190.                                                   key=10;
  3191.                                                   break;
  3192.                                             }
  3193.                                           }while(1);
  3194.                                         }
  3195.                                         if(key==10) break;
  3196.                                   }
  3197.                                   break;
  3198.                 }
  3199.                 key=99;save=d;
  3200.           }
  3201.           if(key==99) break;
  3202.         }while(1);
  3203.   }while(1);
  3204. }


  3205. /*=====================================================================================
  3206. 函数名称:版本信息
  3207. 功能描述:  
  3208. 全局变量:
  3209. 参数说明:见函数
  3210. 返回说明:无
  3211. 设 计 人:LIJH
  3212. 版    本:1.0
  3213. 说    明:
  3214. ======================================================================================*/

  3215. void version_func(void)
  3216. {
  3217.   uchar save,v=0;
  3218.   display_cnasc(0x82,3,"版  本");
  3219.   dis_title_e();
  3220.   do
  3221.   {
  3222.         display_cnasc(0x90,7,version[v]);
  3223.         display_cnasc(0x88,7,version[v+1]);
  3224.         display_cnasc(0x98,7,version[v+2]);
  3225.         if(v!=0) display_cnasc(0x97,1," \x1e");
  3226.         else if(v==0)
  3227.           display_cnasc(0x97,1,"院");
  3228.         else display_cnasc(0x97,1,"  ");
  3229.         if(v!=7) display_cnasc(0x9f,1," \x1f");
  3230.         else display_cnasc(0x9f,1,"  ");
  3231.         save=gotkey();
  3232.         if(save==2&&v<7)
  3233.         {
  3234.           display_cnasc(0x9f,1," \x04");
  3235.       delay(30000);
  3236.           v++;
  3237.         }
  3238.         if(save==5&&v>0)
  3239.         {
  3240.           display_cnasc(0x97,1," \x04");
  3241.       delay(30000);
  3242.           v--;
  3243.         }
  3244.         if(save==1) return;
  3245.         if((save==11||save==3)&&v==7)
  3246.         {
  3247.           display_cnasc(0x9e,2,") \x09 ");
  3248.       delay(30000);
  3249.           return;         
  3250.         }
  3251.   }while(1);
  3252. }



  3253. /*=====================================================================================
  3254. 函数名称:系统主函数
  3255. 功能描述:  
  3256. 全局变量:
  3257. 参数说明:见函数
  3258. 返回说明:无
  3259. 设 计 人:LIJH
  3260. 版    本:1.0
  3261. 说    明:
  3262. ======================================================================================*/
  3263. void  main()
  3264. {
  3265.   uchar key;                                                         
  3266.   init_lcd();
  3267.   display_cnasc(0x92,4,"欢迎使用");                                                 // 初始化lcd
  3268.   lcd_bl=als_tl=als_th=buzzer=pw_oc=close;
  3269.   key=r1302(d02_initsi+1);            // 读出1302初始化标记位
  3270.   if(bl1) lcd_bl=close;
  3271.   else lcd_bl=open;
  3272.   display_cnasc(0x92,4,"欢迎使用");   // 显示开机画面“欢迎使用”
  3273.   display_cnasc(0x9d,3,"—LiJH");
  3274.   if(key!=0xb4)  init_ds1302();       // DS1302初始化
  3275.   rds1302_data();                                          // 开机读回设置数据
  3276.   rds1302_date();
  3277.   rds1302_time();                     // 读日期时间   
  3278.   if(!ds18b20) init_ds18b20();                  // 初始化18b20
  3279.   if(ds18b20)
  3280.   {                                               
  3281.         ds18b20_func();                                           // 读出温度
  3282.   }
  3283.   time_init();                         // 定时器初始化
  3284.   delay_pw();resu[11]=0;
  3285.   while(1)
  3286.   {  
  3287.         EA=1;
  3288.         TR0=1;
  3289.         dis_sig=1;        
  3290.         clear_dis();
  3291.         if(di0){init_d2=1;dis_mode2();init_d2=0;}
  3292.     else if(di1) dis_mode3();
  3293.     else dis_mode1();        
  3294.         do
  3295.         {
  3296.           key=gotkey();
  3297.           if(key==255)                        // 键盘密码输入
  3298.           {
  3299.                 TR0=0;
  3300.                 dis_sig=0;
  3301.                 clear_dis();
  3302.                 dis_title_e();
  3303.                 display_cnasc(0x82,3,"键盘锁");
  3304.                 display_cnasc(0x90,5,"输入密码:");
  3305.                 while(1)
  3306.                 {
  3307.                   keb=0;
  3308.                   key=input_passwork();
  3309.                   if(key==10) {keb=1;resu[11]=2;break;}
  3310.                   key=passwork_comp();
  3311.                   if(key==1) {keb=1;resu[11]=0;break;}           
  3312.                 }
  3313.                 rds1302_date();
  3314.         rds1302_time();
  3315.             save_time=now;
  3316.                 break;
  3317.           }
  3318.           if(key==11)
  3319.           {
  3320.             dis_menu_key(1);
  3321.                 delay(35000);
  3322.                 do
  3323.                 {
  3324.                   dis_sig=0;
  3325.                   TR0=0;
  3326.                   clear_dis();
  3327.                   key=dis_menu();
  3328.                   clear_dis();
  3329.                   if(key==0) adjust_func();
  3330.                   else if(key==1) // 调用相应程序功能S
  3331.                   {
  3332.                     while(1)
  3333.                         {
  3334.                           clear_dis();
  3335.                       key=tool_func();
  3336.                           if(key==4) break;
  3337.                           clear_dis();
  3338.                           switch(key)
  3339.                           {
  3340.                             case 0:        calculator();
  3341.                                         break;
  3342.                                 case 1: temp_func();
  3343.                                             break;
  3344.                                 case 2: alarm_func();
  3345.                                         break;
  3346.                                 case 3: nba_timer();
  3347.                                         break;
  3348.                           }
  3349.                         }
  3350.                   }
  3351.                   else if(key==2)        set_func();
  3352.                   else if(key==3)        passw_func();
  3353.                   else if(key==4) version_func();
  3354.                   else
  3355.                   {
  3356.                     rds1302_date();
  3357.             rds1302_time();
  3358.                         save_time=now;
  3359.                         resu[11]=0;
  3360.                         dis_sig=1;
  3361.                         break;
  3362.                   }
  3363.                 }while(1);
  3364.           }
  3365.           if(dis_sig) break;
  3366.         }while(1);
  3367.   }
  3368. }
复制代码

评分

参与人数 1黑币 +50 收起 理由
admin + 50 回帖助人的奖励!

查看全部评分

回复

使用道具 举报

ID:138273 发表于 2019-1-13 20:05 | 显示全部楼层

你的弄好没
回复

使用道具 举报

ID:337487 发表于 2019-3-18 18:23 | 显示全部楼层
不错,谢谢分享
回复

使用道具 举报

ID:138119 发表于 2019-3-18 19:07 | 显示全部楼层
加油,加油,希望能做出更好的产品
回复

使用道具 举报

ID:482105 发表于 2019-4-13 15:25 来自手机 | 显示全部楼层
能加一下嘛,我想问您点问题,谢谢
回复

使用道具 举报

ID:168637 发表于 2019-4-16 22:13 | 显示全部楼层
写的很好 感谢分享
回复

使用道具 举报

ID:137481 发表于 2019-6-4 01:28 | 显示全部楼层
代码量这么猛。。三千多行 给力
回复

使用道具 举报

ID:570217 发表于 2019-8-3 14:28 | 显示全部楼层
牛逼,学习了。
回复

使用道具 举报

ID:665056 发表于 2019-12-21 11:47 | 显示全部楼层
很给力,厉害
回复

使用道具 举报

ID:97678 发表于 2019-12-21 14:16 | 显示全部楼层
下载来,看看,
回复

使用道具 举报

ID:689598 发表于 2020-2-3 00:57 | 显示全部楼层
比1602空间大多了
回复

使用道具 举报

ID:97678 发表于 2020-2-3 10:30 | 显示全部楼层
能够提供原理图吗?
回复

使用道具 举报

ID:55815 发表于 2020-2-3 13:33 | 显示全部楼层
多谢分享
回复

使用道具 举报

ID:747344 发表于 2020-9-30 16:17 | 显示全部楼层
这个12864可以修改配套stm32
回复

使用道具 举报

ID:82738 发表于 2021-8-29 22:39 来自手机 | 显示全部楼层
menu_index code index_m[6]={{3,5,1},{4,0,2},{5,1,3},{0,2,4},{1,3,5},{2,4,0}}; // 菜单导航
回复

使用道具 举报

ID:82738 发表于 2021-8-29 22:40 来自手机 | 显示全部楼层

menu_index code index_m[6]={{3,5,1},{4,0,2},{5,1,3},{0,2,4},{1,3,5},{2,4,0}}; // 菜单导航
回复

使用道具 举报

ID:82738 发表于 2021-8-29 22:42 来自手机 | 显示全部楼层

menu_index code index_m[6]={{3,5,1},{4,0,2},{5,1,3},{0,2,4},{1,3,5},{2,4,0}}; // 菜单导航,数组是怎么理解的,谢谢
回复

使用道具 举报

ID:82738 发表于 2021-8-29 22:42 来自手机 | 显示全部楼层
menu_index code index_m[6]={{3,5,1},{4,0,2},{5,1,3},{0,2,4},{1,3,5},{2,4,0}}; // 菜单导航
回复

使用道具 举报

ID:82738 发表于 2021-8-29 22:45 来自手机 | 显示全部楼层

menu_index code index_m[6]={{3,5,1},{4,0,2},{5,1,3},{0,2,4},{1,3,5},{2,4,0}}; // 菜单导航的数组是指键盘号吗?
回复

使用道具 举报

ID:105314 发表于 2021-12-23 09:47 | 显示全部楼层
正在研究12864菜单显示,感谢楼主!
回复

使用道具 举报

ID:333678 发表于 2021-12-23 16:46 来自手机 | 显示全部楼层
感谢楼主分享!下载学习了。
回复

使用道具 举报

ID:138205 发表于 2021-12-23 19:29 | 显示全部楼层
学习12864,参考参考代码
回复

使用道具 举报

ID:730009 发表于 2022-3-26 20:25 | 显示全部楼层
89s53和89c52兼容不?
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表