设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › LCD240*64液晶单片机驱动程序 一个DS1302开心时钟万年历 ...
返回列表 发新帖
查看: 3963|回复: 0
打印 上一主题 下一主题
收起左侧

LCD240*64液晶单片机驱动程序 一个DS1302开心时钟万年历作品

[复制链接]
跳转到指定楼层
楼主
ID:102668 发表于 2016-1-11 04:06 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
手头有个DS1302时钟芯片，正好学习一下。这个蕊片具有掉电时钟继续走时的特点（要有电池或超级电容）。还是KEIL编程序，PROTEUS做仿真，然后加实物，用的lcd240×64液晶屏，驱动芯片是t6963c，做了一个简单的开心万年历.















关于此屏幕的Proteus仿真文件下载请到：http://www.51hei.com/bbs/dpj-42069-1.html
LCD240*64液晶的51单片机驱动程序：
  1. #include<reg52.h>                                                // 52头文件
  2. #include<intrins.h>                                                //        包含_onp_
  3. #define uchar unsigned char                                //宏定义uchar 为unsigned char
  4. #define uint unsigned int                                //宏定义uint   为unsiened int
  5. #define nop() _nop_()                                         //宏定义延时

  7. #define wds1302_sec                        0x80                //秒数据地址
  8. #define wds1302_min                        0x82                //分数据地址
  9. #define wds1302_hr                        0x84                //时数据地址
  10. #define wds1302_date                0x86                //日数据地址
  11. #define wds1302_month                0x88                //月数据地址
  12. #define wds1302_day                        0x8a                //星期数据地址
  13. #define wds1302_year                0x8c                //年数据地址
  14. #define ds1302_control                0x8e                //控制数据地址
  15. #define ds1302_charger                0x90                 //涓流                        
  16. #define ds1302_clkburst                0xbe
  17. #define rds1302_sec                        0x81                //秒数据地址
  18. #define rds1302_min                        0x83                //分数据地址
  19. #define rds1302_hr                        0x85                //时数据地址
  20. #define rds1302_date                0x87                //日数据地址
  21. #define rds1302_month                0x89                //月数据地址
  22. #define rds1302_day                        0x8b                //星期数据地址
  23. #define rds1302_year                0x8d                //年数据地址

  25. sbit ce=P1^0;          //片选
  26. sbit cd=P1^3;          //命令或数据
  27. sbit rd=P1^4;          //读
  28. sbit wr=P1^5;          //写
  29. sbit rst=P1^6;          //复位
  30. sbit rest=P3^5;    //1302复位
  31. sbit sclk=P3^6;    //1302时钟
  32. sbit io=P3^7;      //1302输入输出口

  34. void read1302display();

  36. //sbit sta0=P2^0;    //测执行命令忙
  37. //sbit sta1=P2^1;    //测读写数据忙
  38. //sbit sta2=P2^3;    //测连续写忙

  40. uchar time_buf1[8]={0x15,0x12,0x04,0x16,0x25,0x00};//年月日时分秒周
  41. uchar buf[8] ;//空年月日时分秒周
  42. //uchar buf1[8];        //存修改完成的时间数据

  44. uint text_size,graphic_size;                        //定义文本区和图形区宽度
  45. uint text_startaddr,graphic_startaddr;              //文本和图形土起始位
  46. uint text_startaddr_l,text_startaddr_h;             //定义文本区起始高位低位置
  47. uint graphic_startaddr_l,graphic_startaddr_h;       //定义图形区首地址
  48. uint *p;                                            //图片数据指针
  49. uint t,t1,key;                                                                                        //中断计数变量
  50. uchar bcd[2];                                                                                //从DS1302读出数据转BCD码
  51. uchar flag=0,next;                                        //进入调节标志位
  52. uchar yx=0;                                                                                        //键盘返回有效的值
  53. uchar code cgtab[]={
  54. //--黑点   --
  55.       0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
  56.       0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
  57.       0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
  58.       0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,         
  59. //-- 年 --
  60.       0x08,0x08,0x1F,0x11,0x21,0x41,0x1F,0x11,
  61.       0x11,0x11,0xFF,0x01,0x01,0x01,0x01,0x01,
  62.       0x00,0x08,0xFC,0x00,0x00,0x10,0xF8,0x00,
  63.       0x00,0x04,0xFE,0x00,0x00,0x00,0x00,0x00,
  64. //-- 月 --
  65.       0x00,0x0F,0x08,0x08,0x08,0x0F,0x08,0x08,
  66.       0x08,0x0F,0x08,0x08,0x10,0x10,0x20,0x40,
  67.       0x10,0xF8,0x10,0x10,0x10,0xF0,0x10,0x10,
  68.       0x10,0xF0,0x10,0x10,0x10,0x10,0x50,0x20,
  69. //-- 日 --
  70.       0x00,0x1F,0x10,0x10,0x10,0x10,0x10,0x1F,
  71.       0x10,0x10,0x10,0x10,0x10,0x1F,0x10,0x00,
  72.       0x10,0xF8,0x10,0x10,0x10,0x10,0x10,0xF0,
  73.       0x10,0x10,0x10,0x10,0x10,0xF0,0x10,0x00,
  74. //-- 时 --
  75.       0x00,0x04,0x7E,0x44,0x47,0x44,0x44,0x7C,
  76.       0x44,0x44,0x44,0x44,0x7C,0x44,0x00,0x00,
  77.       0x08,0x08,0x08,0x08,0xFE,0x08,0x08,0x88,
  78.       0x48,0x48,0x08,0x08,0x08,0x48,0x28,0x10,
  79. //-- 分 --
  80.       0x00,0x04,0x04,0x08,0x08,0x10,0x20,0x4F,
  81.       0x84,0x04,0x04,0x04,0x04,0x08,0x11,0x20,
  82.       0x80,0x80,0x40,0x40,0x20,0x10,0x08,0xEE,
  83.       0x24,0x20,0x20,0x20,0x20,0x20,0x40,0x80,
  84. //-- 秒 --
  85.       0x04,0x0E,0x78,0x08,0x08,0xFE,0x08,0x1D,
  86.       0x1A,0x28,0x28,0x48,0x88,0x08,0x08,0x0B,
  87.       0x20,0x20,0x20,0x20,0xA8,0xA6,0xA2,0x20,
  88.       0x24,0x24,0x28,0x10,0x20,0x40,0x80,0x00,
  89. //-- 周 --
  90.       0x00,0x3F,0x21,0x21,0x2F,0x21,0x21,0x3F,
  91.       0x20,0x27,0x24,0x24,0x24,0x47,0x84,0x00,
  92.       0x08,0xFC,0x08,0x48,0xE8,0x08,0x28,0xF8,
  93.       0x48,0xE8,0x48,0x48,0x48,0xC8,0x28,0x10,
  94. //-- 闹 --
  95.       0x40,0x37,0x10,0x42,0x41,0x5F,0x41,0x41,
  96.       0x4F,0x49,0x49,0x49,0x49,0x41,0x41,0x40,
  97.       0x04,0xFE,0x04,0x04,0x24,0xF4,0x04,0x24,
  98.       0xF4,0x24,0x24,0x24,0x64,0x04,0x14,0x08,
  99. //-- 钟 --
  100.       0x10,0x10,0x10,0x1C,0x21,0x21,0x7D,0x91,
  101.       0x11,0xFD,0x11,0x10,0x14,0x18,0x10,0x00,
  102.       0x20,0x20,0x20,0x24,0xFE,0x24,0x24,0x24,
  103.       0x24,0xFC,0x24,0x20,0x20,0x20,0x20,0x20,
  104. //-- ０ --
  105.       0x00,0x00,0x03,0x06,0x0C,0x0C,0x0C,0x0C,
  106.       0x0C,0x0C,0x0C,0x0C,0x06,0x03,0x00,0x00,
  107.       0x00,0x00,0xE0,0x30,0x18,0x18,0x18,0x18,
  108.       0x18,0x18,0x18,0x18,0x30,0xE0,0x00,0x00,
  109. //-- １ --
  110.       0x00,0x00,0x00,0x03,0x01,0x01,0x01,0x01,
  111.       0x01,0x01,0x01,0x01,0x01,0x03,0x00,0x00,
  112.       0x00,0x00,0x80,0x80,0x80,0x80,0x80,0x80,
  113.       0x80,0x80,0x80,0x80,0x80,0xC0,0x00,0x00,
  114. //-- ２ --
  115.       0x00,0x00,0x03,0x06,0x0C,0x0C,0x00,0x00,
  116.       0x00,0x00,0x01,0x03,0x06,0x0F,0x00,0x00,
  117.       0x00,0x00,0xC0,0x60,0x30,0x30,0x30,0x30,
  118.       0x60,0xC0,0x80,0x10,0x10,0xF0,0x00,0x00,
  119. //-- ３ --
  120.       0x00,0x00,0x03,0x06,0x0C,0x00,0x00,0x01,
  121.       0x00,0x00,0x00,0x0C,0x06,0x03,0x00,0x00,
  122.       0x00,0x00,0xC0,0x60,0x30,0x30,0x60,0xC0,
  123.       0x60,0x30,0x30,0x30,0x60,0xC0,0x00,0x00,
  124. //-- ４ --
  125.       0x00,0x00,0x00,0x01,0x03,0x02,0x06,0x0C,
  126.       0x0C,0x18,0x1F,0x00,0x00,0x01,0x00,0x00,
  127.       0x00,0x40,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,
  128.       0xC0,0xC0,0xF0,0xC0,0xC0,0xE0,0x00,0x00,
  129. //-- ５ --
  130.       0x00,0x00,0x0F,0x0C,0x0C,0x0C,0x0F,0x0E,
  131.       0x00,0x00,0x00,0x0C,0x06,0x03,0x00,0x00,
  132.       0x00,0x00,0xF0,0x00,0x00,0x00,0xC0,0x60,
  133.       0x30,0x30,0x30,0x30,0x60,0xC0,0x00,0x00,
  134. //-- ６ --
  135.       0x00,0x00,0x03,0x06,0x0C,0x0C,0x0D,0x0E,
  136.       0x0C,0x0C,0x0C,0x0C,0x06,0x03,0x00,0x00,
  137.       0x00,0x00,0xC0,0x60,0x30,0x00,0xC0,0x60,
  138.       0x30,0x30,0x30,0x30,0x60,0xC0,0x00,0x00,
  139. //-- ７ --
  140.       0x00,0x00,0x0F,0x0F,0x08,0x00,0x00,0x00,
  141.       0x01,0x01,0x03,0x03,0x03,0x03,0x00,0x00,
  142.       0x00,0x00,0xF0,0xF0,0x30,0x60,0xC0,0xC0,
  143.       0x80,0x80,0x00,0x00,0x00,0x00,0x00,0x00,
  144. //-- ８ --
  145.       0x00,0x00,0x03,0x06,0x0C,0x0C,0x06,0x03,
  146.       0x06,0x0C,0x0C,0x0C,0x06,0x03,0x00,0x00,
  147.       0x00,0x00,0xC0,0x60,0x30,0x30,0x60,0xC0,
  148.       0x60,0x30,0x30,0x30,0x60,0xC0,0x00,0x00,
  149. //-- ９ --
  150.       0x00,0x00,0x03,0x06,0x0C,0x0C,0x0C,0x0C,
  151.       0x06,0x03,0x00,0x0C,0x06,0x03,0x00,0x00,
  152.       0x00,0x00,0xC0,0x60,0x30,0x30,0x30,0x30,
  153.       0x70,0xF0,0x30,0x30,0x60,0xC0,0x00,0x00,
  154. //-- ： --
  155.       0x00,0x00,0x00,0x00,0x00,0x00,0x06,0x0F,
  156.       0x0F,0x06,0x00,0x06,0x0F,0x0F,0x06,0x00,
  157.       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  158.       0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  159. //-- 祝 --
  160.       0x20,0x13,0x12,0x02,0xFE,0x0A,0x12,0x3B,
  161.       0x56,0x90,0x10,0x11,0x11,0x12,0x14,0x18,
  162.       0x08,0xFC,0x08,0x08,0x08,0x08,0x08,0xF8,
  163.       0xA8,0xA0,0xA0,0x20,0x22,0x22,0x1E,0x00,
  164. //-- 您 --
  165.       0x09,0x09,0x13,0x12,0x34,0x59,0x91,0x12,
  166.       0x14,0x11,0x10,0x02,0x51,0x50,0x90,0x0F,
  167.       0x00,0x00,0xFC,0x04,0x48,0x40,0x50,0x4C,
  168.       0x44,0x40,0x80,0x00,0x84,0x92,0x12,0xF0,
  169. //-- 刻 --
  170.       0x08,0x04,0x04,0xFF,0x04,0x08,0x10,0x7F,
  171.       0x02,0x04,0x09,0x72,0x06,0x19,0xE0,0x00,
  172.       0x04,0x04,0x84,0xC4,0x04,0xA4,0xA4,0x24,
  173.       0x24,0xA4,0x24,0x24,0x04,0x84,0x94,0x08,
  174. //-- 都 --
  175.       0x10,0x12,0x7F,0x12,0x14,0xFF,0x08,0x12,
  176.       0x3F,0x62,0xA2,0x3E,0x22,0x22,0x3E,0x22,
  177.       0x00,0x7C,0x44,0x44,0x48,0x48,0x50,0x48,
  178.       0x44,0x42,0x42,0x62,0x54,0x48,0x40,0x40,
  179. //-- 开 --
  180.       0x00,0x7F,0x08,0x08,0x08,0x08,0x08,0xFF,
  181.       0x08,0x08,0x08,0x08,0x10,0x10,0x20,0x40,
  182.       0x08,0xFC,0x20,0x20,0x20,0x20,0x24,0xFE,
  183.       0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
  184. //-- 心 --
  185.       0x02,0x01,0x00,0x00,0x08,0x08,0x28,0x28,
  186.       0x28,0x48,0x88,0x08,0x08,0x08,0x07,0x00,
  187.       0x00,0x00,0x80,0xC0,0x80,0x00,0x08,0x04,
  188.       0x02,0x02,0x02,0x00,0x10,0x10,0xF0,0x00,
  189. //-- 间 --
  190.       0x20,0x1B,0x08,0x40,0x4F,0x48,0x48,0x48,
  191.       0x4F,0x48,0x48,0x48,0x4F,0x48,0x40,0x40,
  192.       0x04,0xFE,0x04,0x24,0xF4,0x24,0x24,0x24,
  193.       0xE4,0x24,0x24,0x24,0xE4,0x24,0x14,0x08
  194. };                 

  196. /*********************延时函数************************************/
  197. void delay(uint a)
  198. {
  199.         uchar b;
  200.         for( ;a>0;a--)
  201.         for(b=110;b>0;b--);
  202. }

  204. /***********************键盘扫描************************************/
  205. char key_scan()
  206. {
  207.         uchar temp;                        //定义变量
  208.         P0=0xef;                                //把高位一条拉低电平 11101111 给P0
  209.         temp=P0;                                //把P0口电平读回给临时变量
  210.         if((temp&0x0f)!=0x0f)        //检测有无按键按下
  211.         {  
  212.             delay(10);                                //延时10毫秒
  213.             
  214.             temp=P0;                                //把P0口数值读给变量
  215.                 P0=0xef;                                //重新给P0口赋值
  216.                 if((temp&0x0f)!=0x0f)        //检测有无按键按下
  217.                 {
  218.                          temp=P0;                        //把P0口数值读给变量
  219.                         switch(temp)                //分支选择数值
  220.                         {
  221.                                 case 0xee:                 //11101110 按键1按下
  222.                                         key=1;         //按键值为1
  223.                                                 
  224.                                         break;         //返回退出
  225.                                 case 0xed:                 //11101101 按键4按下
  226.                                                 key=4;         //按键值为4
  227.                                                 break;         //返回退出
  228.                                 case 0xeb:                 //11101011 按键7按下
  229.                                         key=7;         //按键值为7
  230.                                                 break;         //返回退出
  231.                                 case 0xe7:                 //11100111 按键*按下
  232.                                         key='*'; //按键值为*
  233.                                                 break;          //返回退出
  234.                         }
  235.                         while(temp!=0x0f)          //等待按键抬起
  236.                         {
  237.                                 temp=P0;                  // 把P0数值给变量
  238.                                 temp=temp&0x0f;          // 检测按键是否抬起
  239.                         }
  240.                   yx=1;                   //键盘输入值有效  
  241.                 }

  243.         }
  244.         P0=0xdf;                                //把高位拉低一条 11011111  值给P0
  245.         temp=P0;                                //把P0口电平读回给临时变量
  246.         if((temp&0x0f)!=0x0f)        //检测有无按键按下
  247.         {  
  248.             delay(10);                                   //延时10毫秒
  249.             P0=0xdf;                                        //再把数值给P0
  250.             temp=P0;                                        //P0数值读给变量
  251.                 if((temp&0x0f)!=0x0f)                //再次检测有无键按下
  252.                 {
  253.                          temp=P0;                                //把P0口数值赋给变量
  254.                         switch(temp)                        //分支选择
  255.                         {
  256.                                 case 0xde:                        //11011110 按键2按下
  257.                                         key=2;                //按键值为2
  258.                                         break;                //返回退出
  259.                                 case 0xdd:                        //11011101 按键5按下
  260.                                                 key=5;                //按键值为5
  261.                                                 break;                //返回退出
  262.                                 case 0xdb:                        //11011011 按键8按下
  263.                                         key=8;                //按键值为8
  264.                                                 break;                //退出返回
  265.                                 case 0xd7:                        //11010111 按键0按下
  266.                                         key=0;                //返回值为0
  267.                                                 break;                //返回退出               
  268.                         }
  269.                           while(temp!=0x0f)          //等待按键抬起
  270.                         {
  271.                                 temp=P0;                  // 把P0数值给变量
  272.                                 temp=temp&0x0f;          // 检测按键是否抬起
  273.                         }
  274.                   yx=1;                   //键盘输入值有效  
  275.                 }

  277.         }
  278.         P0=0xbf;                                //把高位拉低一条，10111111 把值给P0口
  279.         temp=P0;                                //把P0口电平读回给临时变量
  280.         if((temp&0x0f)!=0x0f)        //检测有无按键按下
  281.         {  
  282.             delay(10);                                 //延时10毫秒
  283.             P0=0xbf;                                 //把值再给P0口
  284.             temp=P0;                                 //读回P0口实际值
  285.                 if((temp&0x0f)!=0x0f)         //再检测有无按键按下
  286.                 {
  287.                          temp=P0;                         //重新读回P0口值
  288.                         switch(temp)                 //分支选择
  289.                         {
  290.                                 case 0xbe:                 //10111110 按键3按下
  291.                                         key=3;         //按键值为3
  292.                                                 yx=1;    //键盘输入值有效
  293.                                         break;         //返回退出
  294.                                 case 0xbd:                 //10111101 安键6按下
  295.                                                 key=6;         //按键值为6
  296.                                                 yx=1;                          //键盘输入值有效
  297.                                                 break;         //返回退出
  298.                                 case 0xbb:                 //10111011 按键9按下
  299.                                         key=9;         //按键值为9
  300.                                                 yx=1;                          //键盘输入值有效
  301.                                                 break;         //返回退出
  302.                                 case 0xb7:                 //10110111 按键#按下
  303.         //                                key='#';  //按键值为#
  304.                                                 flag=1;
  305.                                                 break;          //返回退出                        
  306.                         }
  307.                           while(temp!=0x0f)          //等待按键抬起
  308.                         {
  309.                                 temp=P0;                  // 把P0数值给变量
  310.                                 temp=temp&0x0f;          // 检测按键是否抬起
  311.                         }
  312.                         
  313.                 }

  315.         }
  316.                           
  317.            return key;                   //函数结束返回按键数值           
  318. }

  320. /****************************ds1302写数据******************************/
  321. void write_date(uchar date)
  322. {
  323.         uchar i,k;                                          //定义变量
  324.         k=date;                                                  //数据赋给变量
  325.         rest=0;                    //置复位为0
  326.         sclk=0;
  327.         rest=1;                    //选中蕊片
  328. //        k=k>>1;
  329.         for(i=0;i<8;i++)           //循环8位数据
  330.         {
  331.                
  332.                 if(k&0x01)io=1;         //取出K低位给IO口
  333.                 sclk=0;                                  //拉低时钟
  334.                 sclk=1;                //拉高时钟数据给DS1302
  335.                
  336.                 k=k>>1;                //变量右移一位
  337.         }
  338.         rest=0;
  339.         sclk=0;
  340. }
  341.   
  342. /**************************ds1302地址写入数据****************************/
  343. void write_ad_dat(uint addr,uchar date)
  344. {                                                                                
  345.         uchar i;                                                        //        定义变量
  346.     rest=0;                                                                //        复位片选
  347.         sclk=0;                                                                //        拉低时钟
  348.     rest=1;                                                                //        置位片选
  349.     for(i=0;i<8;i++)                                        //        8次循环
  350.         {
  351.                 io=addr&0x01;                                        // 把地址中低位给IO口
  352.                 sclk=1;                                                        //        拉高时钟使数据有效
  353.                 sclk=0;                                                  //        拉低时钟给下个高电平做准备
  354.                 addr>>=1;                                          //        地址数据右移一位
  355.         }
  356.         for(i=0;i<8;i++)                                 //        8次循环
  357.         {
  358.                 io=date&0x01;                                  //        把数据低位给IO口
  359.                 sclk=1;                                                  //        拉高时钟，使数据有效
  360.                 sclk=0;                                                  //        拉低时钟
  361.                 date>>=1;                                          //        数据右移一位
  362.         }                                                                  
  363.         rest=0;                                                         //        复位片选
  364. }

  366. /***************************读1302数据***********************************/
  367. uchar read_date()
  368. {
  369.         uchar i,k;                                        //定义变量
  370.         rest=1;                                                //片选为置位
  371.         sclk=1;                                                //拉高1302时钟
  372.         for(i=0;i<8;i++)                        //8位数据循环
  373.         {         
  374.                
  375.                 if(io)                                 //读IO口状态给变量K
  376.                 {
  377.                         k=k|0x80;                 //如果IO口为1，变量赋值为1
  378.                 }
  379.                 sclk=1;                              //拉高时钟                                       
  380.            delay(1);
  381.                 sclk=0;                                        //拉低时钟写入数据
  382.                 k=k>>1;                                        //变量数据右移一位
  383.         }
  384.         rest=0;                     //关片选
  385.         return k;                                        //8位数据结束返回变量数值
  386. }

  388. /********************************读地址数据********************************/
  389. uchar read_add_dat(uint addr)
  390. {        
  391.          uchar i,j;                                                //定义变量
  392.         rest=0;                                                        //复位片选
  393.         sclk=0;                                                        // 拉低时钟电平
  394.         rest=1;                                                        // 置位片选
  395.         for(i=0;i<8;i++)                                // 8位循环
  396.         {
  397.                 sclk=0;                                                // 拉低时钟
  398.                 io=addr&0x01;                                // 地址数据低位给IO口
  399.                 sclk=1;                                          //  拉高时钟，使数据有效
  400.                 addr>>=1;                                        // 地址数据右移一位
  401.         }
  402.         for(i=0;i<8;i++)                          //  8次循环
  403.         {
  404.                 j>>=1;                                          //  变量右移一位
  405.                 sclk=0;                                         //        拉低时钟
  406.                 if(io) j|=0x80;                         //        如果IO口读出高电平，给变量高位置1
  407.            sclk=1;                                         //        拉高电平给下次读数据做准备
  408.         }
  409.         rest=0;                                                 //        复位片选
  410.         return j;                                        //                返回读出的变量值
  411. }
  412. /*******************写命令*****************************************/
  413. void wrcomm(uchar comm)
  414. {
  415.         ce=0;                        //选中芯 片
  416.         rd=1;                        //读高电平无效
  417.         cd=1;           //操作命令
  418.         wr=0;           //写使能
  419.         P2=comm;         //把命令送给总线
  420.         nop();                        //延时
  421.         wr=1;                        //拉高写
  422. }

  424. /*******************写数据******************************************/
  425. void wrdate(uchar date)
  426. {
  427.         ce=0;           //使能片选
  428.         rd=1;                        //读无效
  429.         cd=0;           //操作命令
  430.         wr=0;           //使能写
  431.         P2=date;                //数据送给总线
  432.         nop();                        //延时
  433.         wr=1;                        //拉高写
  434. }

  436. /*******************测读写命令忙***********************************/
  437. void check_sta01()
  438. {
  439.     uchar a;    //定义变量
  440.         ce=0;           //使能片选
  441.         wr=1;           //禁写
  442.         cd=1;           //命令有效
  443.         while(1)                //循环
  444.         {
  445.            P2=0xff;        //P2口为已知的高电平
  446.                 rd=0;       //使能读
  447.                 a=P2;       //读总线状态
  448.                 nop();      //延时
  449.                 rd=1;       //拉高读
  450.                 if((a&0x03)==0x03)        //测试等于0000 0011         
  451.                 return;      //测试如果读写数据为不忙跳出循环
  452.         }
  453. }

  455. /*******************测试连续写忙************************************/
  456. void check_sta03()
  457. {
  458.     uchar a;           //定义变量
  459.         ce=0;                 //全能片选
  460.         wr=1;                 //禁写
  461.         cd=1;                 //命令有效
  462.         while(1)
  463.         {
  464.                 P2=0xff;                  //使P2为已知的高电平
  465.                 rd=0;                          //使能读
  466.                 a=P2;              //读总线状态
  467.                 nop();             //延时
  468.                 rd=1;              //拉高读
  469.                 if((a&0x08)==0x08)        //测试等于00001000
  470.                 return;            //测试如果连续读为不忙跳出循环
  471.         }
  472. }

  474. /************************写无参数命令************************************/
  475. void no_parameter(uchar comm)
  476. {
  477.         check_sta01();              //测忙
  478.         wrcomm(comm);            //写命令
  479. }

  481. /************************写双字节参数命令*********************************/
  482. void double_parameter(uint a,uint b,uchar c)
  483. {
  484.         check_sta01();              //测忙
  485.         wrdate(a);               //写第一字节参数
  486.         check_sta01();              //测忙
  487.         wrdate(b);               //写第二节节参数
  488.         check_sta01();              //测忙
  489.         wrcomm(c);               //写命令
  490. }

  492. /************************清屏全亮或全灭***********************************/
  493. void all_display(uchar state,uchar vlue)
  494. {
  495.     uint i,k;                         //定义变量
  496.         if(state==0)                     //判断state是否为0为文本区
  497.         {
  498.                 double_parameter(text_startaddr_l,text_startaddr_h,0x24);   //文本区低位和高位起始地址
  499.                 no_parameter(0xb0);                                         //连续写命令
  500.                 for(i=1;i<9;i++)
  501.                 {
  502.                    for(k=0;k<30;k++)                                                          //每行为30字符（240*64 ）
  503.                         {
  504.                           check_sta03();                              //测忙
  505.                           wrdate(vlue);
  506.                         }                                              //写入vlue值，0或1
  507.                 }
  508.                 check_sta03();                                                                          //测忙
  509.                 wrcomm(0xb2);                                                                          //关连续写
  510.         }
  511.         if(state==1)                         //判断state是否为1
  512.         {
  513.                 double_parameter(graphic_startaddr_l,graphic_startaddr_h,0x24);    //图开形区起始低，高位
  514.                 no_parameter(0xb0);                                                                                          //连续写命令
  515.                 for(i=30*64;i>0;i--)                                                                                  //循环
  516.                 {
  517.                         check_sta03();                                                                                          //测连续写忙
  518.                         wrdate(vlue);                                                                                          //写入vlue值
  519.                 }
  520.                 check_sta03();                                                                                                  //测忙
  521.                 wrcomm(0xb2);                                                                                                  // 关闭连续写
  522.         }
  523. }

  525. /****************************文本方式下写8*8字符******************************************/
  526. void text_ascii(uchar *addr,uchar hang,uchar lie)
  527. {
  528.         uchar temp;                                                                        //定义变量
  529.         uchar low;                                                                        //定义变量
  530.         uchar high;                                                                        //定义变量
  531.         temp=30*(hang-1)+(lie-1);                                        //每行30字符乘行加列，计算写入起始位置
  532.         low=temp&0x00ff;                                                        //把结果低位赋给低变量
  533.         high=(temp>>8)&0x00ff;                                                //把结果高位给高变量
  534.         double_parameter(low,high,0x24);                        //写入文本起始位置
  535.         no_parameter(0xb0);                                                        //连续写命令
  536.         check_sta03();                                                                //测忙
  537.         wrdate(*addr);                                                                //写入字符地址指针
  538.         check_sta03();                                                                //测连续写忙
  539.         wrcomm(0xb2);                                                           //关闭连续写
  540. }

  542. /**************************graphic下显示图片*********************************************/
  543. void display(uchar *p,uchar hang,uchar lie)
  544. {
  545.         uchar m,n;                                                                                        //定义变量
  546.         uint temp;                                           //定义变量
  547.         temp=(hang-1)*30+lie;                                //计算图形写入地址
  548.         graphic_startaddr_l=temp&0x00ff;                     //取出低位数据
  549.         graphic_startaddr_h=(temp>>8)&0x00ff;
  550.         double_parameter(graphic_startaddr_l,graphic_startaddr_h,0x24);//写入图形首地址
  551.         no_parameter(0xb0);                                                                        //连续写命令
  552.         for(m=240;m>0;m--)                                                                        //循环行数
  553.         {
  554.                 for(n=30;n<0;n--)                                                                //每字节8位，列数/8
  555.                 {
  556.                         check_sta03();                                                                //测忙
  557.                         wrdate(* p++);                                                                //写入图形指针，然后加1地址
  558.                 }
  559.         }
  560.     check_sta03();                                                                                 //测忙
  561.         wrcomm(0xb2);                                                                             //关闭连续写
  562. }

  564. /************************text下显示16*16汉字**********************************************
  565. ***************text模式下是8*8字符，每个汉字要4个字符组成*********************************/
  566. void hz_display(uchar addr,uchar hang,uchar lie)
  567. {
  568.         uint temp;                                                  //定义变量
  569.         uchar low,high;                                          //定义变量
  570.         temp=30*2*(hang-1)+(lie-1)*2;          //把字的坐标地址赋给变量
  571.         low=temp&0x00ff;                                  //取出坐标低位数值
  572.         high=(temp>>8)&0x00ff;                          //右移8位取出坐标高位数值
  573.         double_parameter(low,high,0x24);   //写入汉字坐标
  574.         no_parameter(0xb0);                                  //开连续写
  575.         check_sta03();                                          //测忙
  576.         wrdate(addr);                                          //写入汉字左上4分之1
  577.         check_sta03();                                          //测试忙
  578.         wrdate(addr+2);                                          //写入汉字右上4分之1
  579.         check_sta03();                                          //测忙
  580.         wrcomm(0xb2);                                      //关闭连续写
  581.         delay(1);
  582.         temp=30*2*(hang-1)+30+(lie-1)*2;          //重新计算汉字坐标也就是写下部份，地址加一行（8*8）
  583.         low=temp&0x00ff;                                  //取出低位数值给变量
  584.         high=(temp>>8)&0x00ff;                          //右移8位取出高位给变量
  585.         double_parameter(low,high,0x24);   //写入新起始地址（写汉字下部份）
  586.         no_parameter(0xb0);                                  //连续写命令
  587.         check_sta03();                                          //测忙
  588.         wrdate(addr+1);                                          //写入汉字左下4分之1
  589.         check_sta03();                                          //测忙
  590.         wrdate(addr+3);                                          //写入汉字右下4分之1
  591.         check_sta03();                                          //测忙
  592.         wrcomm(0xb2);                                      //关闭连续写
  593. }

  595. /******************************自定义汉字写入CGRAM***************************************/
  596. void cgram()
  597. {
  598.         uint m=0;                                                        //定义变量
  599.         double_parameter(0x07,0x00,0x22);        //设定最高的1K为CGRAM  寄存器偏移设定
  600.         double_parameter(0x00,0x3c,0x24);        //
  601.         no_parameter(0xb0);                                   //开连续写
  602.         for(m=0;m<896+32;m++)                                //循环
  603.         {
  604.                 check_sta03();                                   //测忙
  605.                 wrdate(cgtab[m]);                                //写入数据         
  606.         }
  607.         check_sta03();                                           //测忙
  608.         wrcomm(0xb2);                                                //关闭连续写
  609. }


  612. /*****************************定时器初始化*************************************************/
  613. void time()
  614. {
  615.         TMOD=0x01;                                                                //开定时器0
  616.         TH0=(65536-5000)/256;                                        //赋值高
  617.         TL0=(65536-5000)%256;                                        //赋值低
  618.         EA=1;                                                                        //开总中断
  619.         ET0=1;                                                                        //开定时器0中断
  620.         TR0=1;                                                                        //启动定时器0
  621. }

  623. /****************************中断函数*********************************/
  624. void t0time()interrupt 1
  625. {
  626.         TH0=(65536-5000)/256;                                         //重新赋值高位
  627.         TL0=(65536-5000)%256;                                         //重新赋值低位
  628.         t++;                                                                         //变量加
  629.         if(t==1000)                                                                 //变量计数到
  630.         {
  631.                 t=0;                                                                 //t重0开始
  632.                 t1=!t1;                                                                 //t1取反给t1
  633.         }        
  634. }         

  636. /**************************显示汉字基本画面*************************************/
  637. void display1()
  638. {
  639.         hz_display(0x80+(26-1)*4,1,6);                  //开
  640.         hz_display(0x80+(27-1)*4,1,7);                  //心
  641.         hz_display(0x80+(5-1)*4,1,8);                  //时
  642.         hz_display(0x80+(10-1)*4,1,9);                  //钟

  644.         hz_display(0x80+(13-1)*4,2,3);                   //2
  645.     hz_display(0x80+(11-1)*4,2,4);                   //0
  646. //        hz_display(0x80+(12-1)*4,2,5);                   //1
  647. //        hz_display(0x80+(16-1)*4,2,6);                   //5
  648.         hz_display(0x80+(2-1)*4,2,7);                   //年
  649. //        hz_display(0x80+(12-1)*4,2,8);                   //1
  650. //        hz_display(0x80+(13-1)*4,2,9);               //2
  651.         hz_display(0x80+(3-1)*4,2,10);                   //月
  652. //        hz_display(0x80+(15-1)*4,2,12);           //4
  653.         hz_display(0x80+(4-1)*4,2,13);                   //日

  655.         hz_display(0x80+(5-1)*4,3,3);                   //时
  656.         hz_display(0x80+(28-1)*4,3,4);                   //间
  657. //        hz_display(0x80+(12-1)*4,3,6);                  //1
  658. //        hz_display(0x80+(17-1)*4,3,7);                  //6
  659.         hz_display(0x80+(21-1)*4,3,8);                  //：
  660. //        hz_display(0x80+(13-1)*4,3,9);                  //2
  661. //        hz_display(0x80+(16-1)*4,3,10);                  //5
  662.         hz_display(0x80+(6-1)*4,3,11);                  //分
  663.         hz_display(0x80+(7-1)*4,3,14);                  //秒

  665.         hz_display(0x80+(22-1)*4,4,2);                  //祝
  666.         hz_display(0x80+(23-1)*4,4,3);                  //您
  667.         hz_display(0x80+(5-1)*4,4,4);                  //时
  668.         hz_display(0x80+(5-1)*4,4,5);                  //时
  669.         hz_display(0x80+(24-1)*4,4,6);                  //刻
  670.         hz_display(0x80+(24-1)*4,4,7);                  //刻
  671.         hz_display(0x80+(6-1)*4,4,8);                  //分
  672.         hz_display(0x80+(6-1)*4,4,9);                  //分
  673.         hz_display(0x80+(7-1)*4,4,10);                  //秒
  674.         hz_display(0x80+(7-1)*4,4,11);                  //秒
  675.         hz_display(0x80+(25-1)*4,4,12);                  //都
  676.         hz_display(0x80+(26-1)*4,4,13);                  //开
  677.         hz_display(0x80+(27-1)*4,4,14);                  //心                        
  678. }

  680. /**************************INIT************************************************/
  681. void init()
  682. {
  683.          
  684.          time();
  685.     rst=0;                                                                //拉低液晶屏复位脚
  686.         nop();                                                                //延时
  687.         nop();                                                                //延时
  688.         nop();                                                                //延时
  689.         rst=1;                                                                //拉高电平置位
  690.         text_size=graphic_size=30*64;                //文本和图形区宽度
  691.         text_startaddr=0x0000;                            //文本区首地址
  692.         text_startaddr_l=text_startaddr;          //文本首地址低位
  693.         text_startaddr_h=text_startaddr>>8;          //文本首地址高位

  695.         graphic_startaddr=text_startaddr+text_size;         //图形区首地址
  696.         graphic_startaddr_l=graphic_startaddr;                 //图形区首地址低位
  697.         graphic_startaddr_h=graphic_startaddr>>8;         //图形区首地址高位

  699.         double_parameter(text_startaddr_l,text_startaddr_h,0x40);        //写入文本首地址
  700.         double_parameter(30,0x00,0x41);                                                                //写入文本区长度（一行几个字节）
  701.         double_parameter(graphic_startaddr_l,graphic_startaddr_h,0x42);          //写入图形区首地址
  702.         double_parameter(30,0x00,0x43);                                                                                //写入图形区长度（一行几个字节）
  703.                                                                                                                                  
  704.         no_parameter(0x80);                 //文本 或 图形
  705.         no_parameter(0x98);                 //图形开文本关
  706.         all_display(1,0xff);          //表屏全亮
  707.         delay(5000);                         //延时
  708.         no_parameter(0xa7);                 //显示8行光标
  709.         no_parameter(0x94);                 //文本开图形关
  710.     cgram();                                   //把字模写入显示屏自定义的CGRAM里
  711.           all_display(0,0x00);         //把文本区全显示白
  712.            
  713. }

  715. /***********123123************写入DS1302年，月，日，时分数据****************************/
  716. void write1302()
  717. {
  718.    
  719.         write_ad_dat(0x8e,0x00);                   //关闭写保护
  720.         write_ad_dat(wds1302_sec,0x80);                          //暂停
  721.         write_ad_dat(wds1302_year,buf[0]);                  //写年
  722.         write_ad_dat(wds1302_month,buf[1]);        //写月
  723.         write_ad_dat(wds1302_date,buf[2]);         //写天
  724.         write_ad_dat(wds1302_hr,buf[3]);           //写读小时
  725.         write_ad_dat(wds1302_min,buf[4]);          //写分
  726.         write_ad_dat(wds1302_sec,buf[5]);          //写秒
  727.         write_ad_dat(ds1302_control,0x80);               //开写保护
  728. }

  730. /****************************时间调节程序***********************************************/
  731. void time_tz()
  732. {
  733.     uint z;                                                                                        //        定义变量
  734.         uchar s,g;                                                                                // 变量十位，个位，高位，低位
  735.    while(flag)                                                                                //如果#按下表示要调节
  736.                                                            
  737.         {        
  738.             if(next==0)                                                                 //调节年十位标志
  739.                 {
  740.                     write_ad_dat(0x8e,0x00);                 //关闭写保护
  741.                 write_ad_dat(wds1302_sec,0x80);                //暂停1302
  742.                     buf[0]&=0x0f;                                                    //清空年十位，变成0000
  743.                     buf[0]|=key_scan()<<4;                                    //键盘返回值左移4位变高位或上数组高位
  744.                     if(yx)next=1;
  745.                       write_ad_dat(wds1302_year,buf[0]);                  //写年数据                                                         
  746.                     read1302display();                                                  //读出1302中数据
  747.                 hz_display(0x80+0*4,2,5);                            //年十位黑点
  748.                     delay(200);                                                                //延时
  749.                 hz_display(0x80+(11-1+(buf[0]>>4))*4,2,5);   //年十位
  750.                         yx=0;                                                                                 //标志位有效（就是有按键按下）
  751.                  }                                                                                                 //清除按键有效标志位

  753.                 if(next==1)                                                                         //调节年个位标志
  754.                 {                                                                                                
  755.                         buf[0]&=0xf0;                                                                  //清空年个位，变成0000
  756.                     buf[0]|=key_scan();                                                  //键盘返回值或上数组
  757.                     if(yx)next=2;                                                                  //如果如果按键标志位为有效，使调标志到下一调节位
  758.                       write_ad_dat(wds1302_year,buf[0]);                      //写年数据                                                         
  759.                     read1302display();                                                                //读1302中数据供显示
  760.                 hz_display(0x80+0*4,2,6);                                //年个位黑点
  761.                     delay(200);                                                                        //延时
  762.                 hz_display(0x80+(11-1+(buf[0]))*4,2,6);                 //个十位
  763.                         yx=0;                                                                                        //清除键盘有效标志位
  764.                 }

  766.                 if(next==2)                                                                           //月十位调节标志
  767.                 {
  768.                     buf[1]&=0x0f;                                                                  //清空月十位，变成0000
  769.                     if((1>=key_scan())&yx)                                       //测试键盘输入数小于等于1和输入有效都为1
  770.                           {
  771.                                  buf[1]|=key<<4;                                                  //键盘返回值左移4位变高位或上数组高位
  772.                          next=3;                                                                  //使调节标志位到月个位有效
  773.                                 }
  774.                       write_ad_dat(wds1302_month,buf[1]);                   //写月                                                         
  775.                     read1302display();                                                                //读出1302中数据供显示
  776.                 hz_display(0x80+0*4,2,8);                                //月十位黑点
  777.                     delay(200);                                                                        //延时
  778.                 hz_display(0x80+(11-1+(buf[1]>>4))*4,2,8);     //月十位
  779.                         yx=0;                                                                                        //清除键盘输入数值有效位
  780.                  }

  782.                 if(next==3)                                                                                //月个位调节标志
  783.                 {
  784.                         buf[1]&=0xf0;                                                                  //清空月个位，变成0000
  785.                     if((2>=key_scan())&yx)                                                  //测试输入值小于等于2和输入有效
  786.                           {
  787.                            buf[1]|=key;                                                      //键盘返回值或上数组（给数组赋值）
  788.                        next=4;                                                                          //使调节标志位到小时调节
  789.                           }
  790.                       write_ad_dat(wds1302_month,buf[1]);                  //写月                                                         
  791.                     read1302display();                                                          //读1302数据
  792.                 hz_display(0x80+0*4,2,9);                                //月个位黑点
  793.                     delay(200);                                                                        //延时
  794.                 hz_display(0x80+(11-1+(buf[1]&0x0f))*4,2,9);    //月个位
  795.                         yx=0;                                                                                        //清除键盘输入有效位
  796.                 }
  797.                                                                                                                   
  798.                  if(next==4)                                                                           //日十位调节标志
  799.                 {
  800.                     buf[2]&=0x0f;                                                                  //清空日十位，变成0000
  801.                     if((3>=key_scan())&yx)                                       //如果输入值小于等于3和键盘输入地为1
  802.                           {
  803.                                  buf[2]|=key<<4;                                                  //键盘返回值左移4位变高位或上数组高位
  804.                          next=5;                                                                  //使调节标志位到日个位
  805.                                 }
  806.                       write_ad_dat(wds1302_date,buf[2]);                      //写日数据                                                         
  807.                     read1302display();                                                          //读出1302数据
  808.                 hz_display(0x80+0*4,2,11);                            //日十位黑点
  809.                     delay(200);                                                                        //延时
  810.                 hz_display(0x80+(11-1+(buf[2]>>4))*4,2,11);         //日十位
  811.                         yx=0;                                                                                        //清除键盘输入有效
  812.                  }
  813.                                                                                                                         
  814.                 if(next==5)                                                                          //日个位调节标志
  815.                 {
  816.                         buf[2]&=0xf0;                                                                  //清空日个位，变成0000
  817.                     if((9>=key_scan())&yx)                                                //如果输入值小于等于9和输入有效都为1
  818.                           {
  819.                            buf[2]|=key;                                                    //键盘返回值或上数组
  820.                        next=6;                                                                        //使调节标志为时十位有效
  821.                                 if(buf[2]>0x31)next=4;                                        //如果输入的日数据大于31天，回到日十位重新输入
  822.                           }
  823.                       write_ad_dat(wds1302_date,buf[2]);                     //写日数据                                                         
  824.                     read1302display();                                                         //读出1302中数据
  825.                 hz_display(0x80+0*4,2,12);                           //日个位黑点
  826.                     delay(200);                                                                  //延时
  827.                 hz_display(0x80+(11-1+(buf[2]&0x0f))*4,2,12);  //日个位
  828.                         yx=0;                                                                                  //清除键盘输入有效标志
  829.                 }

  831.                 if(next==6)                                                                          //小时调节标志
  832.                 {
  833.                     buf[3]&=0x0f;                                                                  //清空时十位，变成0000
  834.                     if((2>=key_scan())&yx)                                       //如果输入的值小于等于2，和键盘输入有效
  835.                           {
  836.                                  buf[3]|=key<<4;                                                  //键盘返回值左移4位变高位或上数组高位
  837.                          next=7;                                                                  //使调节标志位以小时的个位
  838.                                 }
  839.                       write_ad_dat(wds1302_hr,buf[3]);                      //写小时数据                                                         
  840.                     read1302display();                                                          //读1302数据
  841.                 hz_display(0x80+0*4,3,6);                                //时十位黑点
  842.                     delay(200);                                                                        //延时
  843.                 hz_display(0x80+(11-1+(buf[3]>>4))*4,3,6);     //时十位
  844.                         yx=0;
  845.                  }
  846.                                                                                                                  
  847.                 if(next==7)                                                                         //小时个位调节标志
  848.                 {
  849.                         buf[3]&=0xf0;                                                                 //清空时个位，变成0000
  850.                     if((9>=key_scan())&yx)                                                 //输入值和输入有效都为1
  851.                           {
  852.                            buf[3]|=key;                                                     //键盘返回值或上数组
  853.                        next=8;                                                                         //调节标志位到分十位
  854.                                 if(buf[3]>=0x24)next=6;                                         //如果输入的数值大于24，返回时十位重新输入
  855.                           }
  856.                       write_ad_dat(wds1302_hr,buf[3]);                      //写时数据                                                         
  857.                     read1302display();                                                          //读1302中数据
  858.                 hz_display(0x80+0*4,3,7);                               //时个位黑点
  859.                     delay(200);                                                                  //延时
  860.                 hz_display(0x80+(11-1+(buf[3]&0x0f))*4,3,7);         //时个位
  861.                         yx=0;                                                                                  //清除键盘输入有效标志位
  862.                 }

  864.                 if(next==8)                                                                           //分十位调节标志
  865.                 {
  866.                     buf[4]&=0x0f;                                                                  //清空分十位，变成0000
  867.                     if((5>=key_scan())&yx)                                       //输入值小于等于5和键盘输入都有效
  868.                           {
  869.                                  buf[4]|=key<<4;                                                  //键盘返回值左移4位变高位或上数组高位
  870.                          next=9;                                                                  //调节标志位到分个位
  871.                                 }
  872.                       write_ad_dat(wds1302_min,buf[4]);                      //写分数据                                                         
  873.                     read1302display();                                                          //读1302中数据
  874.                 hz_display(0x80+0*4,3,9);                               //分十位黑点
  875.                     delay(200);                                                                  //延时
  876.                 hz_display(0x80+(11-1+(buf[4]>>4))*4,3,9);    //分十位
  877.                         yx=0;                                                                                  //清除键盘输入有效标志位
  878.                  }

  880.                 if(next==9)                                                                          //分个位调节标志
  881.                 {
  882.                         buf[4]&=0xf0;                                                                  //清空分个位，变成0000
  883.                     if((9>=key_scan())&yx)                                                  //输入值小于等于9和输入标志都有效
  884.                           {
  885.                            buf[4]|=key;                                                     //键盘返回值或上数组
  886.                        next=10;                                                                 //调节标志位到秒十位
  887.                           }
  888.                       write_ad_dat(wds1302_min,buf[4]);                     //写分数据                                                         
  889.                     read1302display();                                                         //读1302中数据
  890.                 hz_display(0x80+0*4,3,10);                            //分个位黑点
  891.                     delay(200);                                                                        //延时
  892.                 hz_display(0x80+(11-1+(buf[4]&0x0f))*4,3,10);  //分个位
  893.                         yx=0;                                                                                        //清除键盘输入有效标志位
  894.                 }

  896.                 if(next==10)                                                                                 //秒十位调节标志
  897.                 {
  898.                     buf[5]&=0x0f;                                                                  //清空秒十位，变成0000
  899.                     if((5>=key_scan())&yx)                                       //输入值小于等于5和输入有效都为1
  900.                           {
  901.                                  buf[5]|=key<<4;                                                  //键盘返回值左移4位变高位或上数组高位
  902.                          next=11;                                                                  //调节标志位到秒个位
  903.                                 }
  904.                       write_ad_dat(wds1302_sec,buf[5]);                      //写秒数据                                                         
  905.                     read1302display();                                                          //读1302中数据
  906.                 hz_display(0x80+0*4,3,12);                           //秒十位黑点
  907.                     delay(200);                                                                  //延时
  908.                 hz_display(0x80+(11-1+(buf[5]>>4))*4,3,12);         //秒十位
  909.                         yx=0;                                                                                  //清除键盘输入有效标志位
  910.                  }

  912.                 if(next==11)                                                                          //秒个位调节标志
  913.                 {
  914.                         buf[5]&=0xf0;                                                                  //清空秒个位，变成0000
  915.                     if((9>=key_scan())&yx)                                                  //输入值小于等于9和输入有效都为1
  916.                           {
  917.                            buf[5]|=key;                                                      //键盘返回值或上数组
  918.                        next=0;                                                                          //使调节标志位到年十位，为下一次调节做准备
  919.                                 flag=0;                                                                          //清除调节模式，回到正常显示状态
  920.                                 write_ad_dat(ds1302_control,0x80);              //开1302写保护
  921.                           }
  922.                       write_ad_dat(wds1302_sec,buf[5]);                      //写分数据                                                         
  923.                     read1302display();                                                          //读出1302中数据
  924.                 hz_display(0x80+0*4,3,13);                           //分个位黑点
  925.                     delay(200);                                                                  //延时
  926.                 hz_display(0x80+(11-1+(buf[5]&0x0f))*4,3,13);         //分个位
  927.                         yx=0;                                                                                        //清除键盘输入有效标志
  928.                 }
  929.         }
  930. }

  932. /****************123123****读出1302数据并显示**************************************/
  933. void read1302display()
  934. {        uchar h;                                                                //定义变量
  935.     write_ad_dat(0x8e,0x00);                                //开1302写保护
  936.         buf[0]=read_add_dat(rds1302_year);                //读年
  937.         buf[1]=read_add_dat(rds1302_month);                //读月
  938.         buf[2]=read_add_dat(rds1302_date);                //读日
  939.         buf[3]=read_add_dat(rds1302_hr);                //读小时                                            
  940.         buf[4]=read_add_dat(rds1302_min);                //读分钟                                 
  941.         buf[5]=read_add_dat(rds1302_sec);                //读秒                        

  943.         hz_display(0x80+(11-1+(buf[0]>>4))*4,2,5);                     //年十位
  944.         hz_display(0x80+(11-1+(buf[0]&0x0f))*4,2,6);                 //年个位

  946.         hz_display(0x80+(11-1+(buf[1]>>4))*4,2,8);                     //月十位
  947.         hz_display(0x80+(11-1+(buf[1]&0x0f))*4,2,9);             //月个位

  949.         hz_display(0x80+(11-1+(buf[2]>>4))*4,2,11);             //日十位
  950.         hz_display(0x80+(11-1+(buf[2]&0x0f))*4,2,12);             //日个位

  952.         hz_display(0x80+(11-1+(buf[3]>>4))*4,3,6);                     //小时十位
  953.         hz_display(0x80+(11-1+(buf[3]&0x0f))*4,3,7);                 //小时个位

  955.         hz_display(0x80+(21-1)*4,3,8);                                 //：
  956.         hz_display(0x80+(11-1+(buf[4]>>4))*4,3,9);                     //分十位
  957.         hz_display(0x80+(11-1+(buf[4]&0x0f))*4,3,10);                 //分个位

  959.     hz_display(0x80+(11-1+(buf[5]>>4))*4,3,12);                     //秒十位
  960.         hz_display(0x80+(11-1+(buf[5]&0x0f))*4,3,13);                 //秒个位

  962. }
  963. /***************************主程序*******************************************************/
  964. void main()
  965. {
  966.     uchar i;                                                                                  //定义变量
  967.     init();                                                                                          //初屏显示
  968.         display1();                                                                                  //显示汉字画面
  969.         for(i=0;i<8;i++)                                                                  //把原始数据给显示数组
  970.         {
  971.                 buf[i]=time_buf1[i];                                                  //常量数组数据赋给变量数组
  972.         }
  973.         write1302();                                                                          //写入年，月日时，时间数据
  974.         while(1)
  975.         {
  976.              key_scan();                                                                          //  键盘扫描
  977.                 time_tz();                                                                          //  时间调整
  978.                 read1302display();                                                          //读1302数据并显示                                 
  979.         }      
  980. }        
复制代码




lcd240×64液晶屏驱动.rar

52.03 KB, 下载次数: 37, 下载积分: 黑币 -5

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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