找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

帖子
查看: 5049|回復(fù): 0
打印 上一主題 下一主題
收起左側(cè)

LCD240*64液晶單片機驅(qū)動程序 一個DS1302開心時鐘萬年歷作品

[復(fù)制鏈接]
跳轉(zhuǎn)到指定樓層
樓主
ID:102668 發(fā)表于 2016-1-11 04:06 | 只看該作者 回帖獎勵 |倒序瀏覽 |閱讀模式
手頭有個DS1302時鐘芯片，正好學(xué)習(xí)一下。這個蕊片具有掉電時鐘繼續(xù)走時的特點（要有電池或超級電容）。還是KEIL編程序，PROTEUS做仿真，然后加實物，用的lcd240×64液晶屏，驅(qū)動芯片是t6963c，做了一個簡單的開心萬年歷.















關(guān)于此屏幕的Proteus仿真文件下載請到：http://www.torrancerestoration.com/bbs/dpj-42069-1.html
LCD240*64液晶的51單片機驅(qū)動程序：
  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                //秒數(shù)據(jù)地址
  8. #define wds1302_min                        0x82                //分?jǐn)?shù)據(jù)地址
  9. #define wds1302_hr                        0x84                //時數(shù)據(jù)地址
  10. #define wds1302_date                0x86                //日數(shù)據(jù)地址
  11. #define wds1302_month                0x88                //月數(shù)據(jù)地址
  12. #define wds1302_day                        0x8a                //星期數(shù)據(jù)地址
  13. #define wds1302_year                0x8c                //年數(shù)據(jù)地址
  14. #define ds1302_control                0x8e                //控制數(shù)據(jù)地址
  15. #define ds1302_charger                0x90                 //涓流                        
  16. #define ds1302_clkburst                0xbe
  17. #define rds1302_sec                        0x81                //秒數(shù)據(jù)地址
  18. #define rds1302_min                        0x83                //分?jǐn)?shù)據(jù)地址
  19. #define rds1302_hr                        0x85                //時數(shù)據(jù)地址
  20. #define rds1302_date                0x87                //日數(shù)據(jù)地址
  21. #define rds1302_month                0x89                //月數(shù)據(jù)地址
  22. #define rds1302_day                        0x8b                //星期數(shù)據(jù)地址
  23. #define rds1302_year                0x8d                //年數(shù)據(jù)地址

  25. sbit ce=P1^0;          //片選
  26. sbit cd=P1^3;          //命令或數(shù)據(jù)
  27. sbit rd=P1^4;          //讀
  28. sbit wr=P1^5;          //寫
  29. sbit rst=P1^6;          //復(fù)位
  30. sbit rest=P3^5;    //1302復(fù)位
  31. sbit sclk=P3^6;    //1302時鐘
  32. sbit io=P3^7;      //1302輸入輸出口

  34. void read1302display();

  36. //sbit sta0=P2^0;    //測執(zhí)行命令忙
  37. //sbit sta1=P2^1;    //測讀寫數(shù)據(jù)忙
  38. //sbit sta2=P2^3;    //測連續(xù)寫忙

  40. uchar time_buf1[8]={0x15,0x12,0x04,0x16,0x25,0x00};//年月日時分秒周
  41. uchar buf[8] ;//空年月日時分秒周
  42. //uchar buf1[8];        //存修改完成的時間數(shù)據(jù)

  44. uint text_size,graphic_size;                        //定義文本區(qū)和圖形區(qū)寬度
  45. uint text_startaddr,graphic_startaddr;              //文本和圖形土起始位
  46. uint text_startaddr_l,text_startaddr_h;             //定義文本區(qū)起始高位低位置
  47. uint graphic_startaddr_l,graphic_startaddr_h;       //定義圖形區(qū)首地址
  48. uint *p;                                            //圖片數(shù)據(jù)指針
  49. uint t,t1,key;                                                                                        //中斷計數(shù)變量
  50. uchar bcd[2];                                                                                //從DS1302讀出數(shù)據(jù)轉(zhuǎn)BCD碼
  51. uchar flag=0,next;                                        //進入調(diào)節(jié)標(biāo)志位
  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. /*********************延時函數(shù)************************************/
  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口數(shù)值讀給變量
  215.                 P0=0xef;                                //重新給P0口賦值
  216.                 if((temp&0x0f)!=0x0f)        //檢測有無按鍵按下
  217.                 {
  218.                          temp=P0;                        //把P0口數(shù)值讀給變量
  219.                         switch(temp)                //分支選擇數(shù)值
  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數(shù)值給變量
  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;                                        //再把數(shù)值給P0
  250.             temp=P0;                                        //P0數(shù)值讀給變量
  251.                 if((temp&0x0f)!=0x0f)                //再次檢測有無鍵按下
  252.                 {
  253.                          temp=P0;                                //把P0口數(shù)值賦給變量
  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數(shù)值給變量
  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數(shù)值給變量
  310.                                 temp=temp&0x0f;          // 檢測按鍵是否抬起
  311.                         }
  312.                         
  313.                 }

  315.         }
  316.                           
  317.            return key;                   //函數(shù)結(jié)束返回按鍵數(shù)值           
  318. }

  320. /****************************ds1302寫數(shù)據(jù)******************************/
  321. void write_date(uchar date)
  322. {
  323.         uchar i,k;                                          //定義變量
  324.         k=date;                                                  //數(shù)據(jù)賦給變量
  325.         rest=0;                    //置復(fù)位為0
  326.         sclk=0;
  327.         rest=1;                    //選中蕊片
  328. //        k=k>>1;
  329.         for(i=0;i<8;i++)           //循環(huán)8位數(shù)據(jù)
  330.         {
  331.                
  332.                 if(k&0x01)io=1;         //取出K低位給IO口
  333.                 sclk=0;                                  //拉低時鐘
  334.                 sclk=1;                //拉高時鐘數(shù)據(jù)給DS1302
  335.                
  336.                 k=k>>1;                //變量右移一位
  337.         }
  338.         rest=0;
  339.         sclk=0;
  340. }
  341.   
  342. /**************************ds1302地址寫入數(shù)據(jù)****************************/
  343. void write_ad_dat(uint addr,uchar date)
  344. {                                                                                
  345.         uchar i;                                                        //        定義變量
  346.     rest=0;                                                                //        復(fù)位片選
  347.         sclk=0;                                                                //        拉低時鐘
  348.     rest=1;                                                                //        置位片選
  349.     for(i=0;i<8;i++)                                        //        8次循環(huán)
  350.         {
  351.                 io=addr&0x01;                                        // 把地址中低位給IO口
  352.                 sclk=1;                                                        //        拉高時鐘使數(shù)據(jù)有效
  353.                 sclk=0;                                                  //        拉低時鐘給下個高電平做準(zhǔn)備
  354.                 addr>>=1;                                          //        地址數(shù)據(jù)右移一位
  355.         }
  356.         for(i=0;i<8;i++)                                 //        8次循環(huán)
  357.         {
  358.                 io=date&0x01;                                  //        把數(shù)據(jù)低位給IO口
  359.                 sclk=1;                                                  //        拉高時鐘，使數(shù)據(jù)有效
  360.                 sclk=0;                                                  //        拉低時鐘
  361.                 date>>=1;                                          //        數(shù)據(jù)右移一位
  362.         }                                                                  
  363.         rest=0;                                                         //        復(fù)位片選
  364. }

  366. /***************************讀1302數(shù)據(jù)***********************************/
  367. uchar read_date()
  368. {
  369.         uchar i,k;                                        //定義變量
  370.         rest=1;                                                //片選為置位
  371.         sclk=1;                                                //拉高1302時鐘
  372.         for(i=0;i<8;i++)                        //8位數(shù)據(jù)循環(huán)
  373.         {         
  374.                
  375.                 if(io)                                 //讀IO口狀態(tài)給變量K
  376.                 {
  377.                         k=k|0x80;                 //如果IO口為1，變量賦值為1
  378.                 }
  379.                 sclk=1;                              //拉高時鐘                                       
  380.            delay(1);
  381.                 sclk=0;                                        //拉低時鐘寫入數(shù)據(jù)
  382.                 k=k>>1;                                        //變量數(shù)據(jù)右移一位
  383.         }
  384.         rest=0;                     //關(guān)片選
  385.         return k;                                        //8位數(shù)據(jù)結(jié)束返回變量數(shù)值
  386. }

  388. /********************************讀地址數(shù)據(jù)********************************/
  389. uchar read_add_dat(uint addr)
  390. {        
  391.          uchar i,j;                                                //定義變量
  392.         rest=0;                                                        //復(fù)位片選
  393.         sclk=0;                                                        // 拉低時鐘電平
  394.         rest=1;                                                        // 置位片選
  395.         for(i=0;i<8;i++)                                // 8位循環(huán)
  396.         {
  397.                 sclk=0;                                                // 拉低時鐘
  398.                 io=addr&0x01;                                // 地址數(shù)據(jù)低位給IO口
  399.                 sclk=1;                                          //  拉高時鐘，使數(shù)據(jù)有效
  400.                 addr>>=1;                                        // 地址數(shù)據(jù)右移一位
  401.         }
  402.         for(i=0;i<8;i++)                          //  8次循環(huán)
  403.         {
  404.                 j>>=1;                                          //  變量右移一位
  405.                 sclk=0;                                         //        拉低時鐘
  406.                 if(io) j|=0x80;                         //        如果IO口讀出高電平，給變量高位置1
  407.            sclk=1;                                         //        拉高電平給下次讀數(shù)據(jù)做準(zhǔn)備
  408.         }
  409.         rest=0;                                                 //        復(fù)位片選
  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. /*******************寫數(shù)據(jù)******************************************/
  425. void wrdate(uchar date)
  426. {
  427.         ce=0;           //使能片選
  428.         rd=1;                        //讀無效
  429.         cd=0;           //操作命令
  430.         wr=0;           //使能寫
  431.         P2=date;                //數(shù)據(jù)送給總線
  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)                //循環(huán)
  444.         {
  445.            P2=0xff;        //P2口為已知的高電平
  446.                 rd=0;       //使能讀
  447.                 a=P2;       //讀總線狀態(tài)
  448.                 nop();      //延時
  449.                 rd=1;       //拉高讀
  450.                 if((a&0x03)==0x03)        //測試等于0000 0011         
  451.                 return;      //測試如果讀寫數(shù)據(jù)為不忙跳出循環(huán)
  452.         }
  453. }

  455. /*******************測試連續(xù)寫忙************************************/
  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;              //讀總線狀態(tài)
  467.                 nop();             //延時
  468.                 rd=1;              //拉高讀
  469.                 if((a&0x08)==0x08)        //測試等于00001000
  470.                 return;            //測試如果連續(xù)讀為不忙跳出循環(huán)
  471.         }
  472. }

  474. /************************寫無參數(shù)命令************************************/
  475. void no_parameter(uchar comm)
  476. {
  477.         check_sta01();              //測忙
  478.         wrcomm(comm);            //寫命令
  479. }

  481. /************************寫雙字節(jié)參數(shù)命令*********************************/
  482. void double_parameter(uint a,uint b,uchar c)
  483. {
  484.         check_sta01();              //測忙
  485.         wrdate(a);               //寫第一字節(jié)參數(shù)
  486.         check_sta01();              //測忙
  487.         wrdate(b);               //寫第二節(jié)節(jié)參數(shù)
  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為文本區(qū)
  497.         {
  498.                 double_parameter(text_startaddr_l,text_startaddr_h,0x24);   //文本區(qū)低位和高位起始地址
  499.                 no_parameter(0xb0);                                         //連續(xù)寫命令
  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);                                                                          //關(guān)連續(xù)寫
  510.         }
  511.         if(state==1)                         //判斷state是否為1
  512.         {
  513.                 double_parameter(graphic_startaddr_l,graphic_startaddr_h,0x24);    //圖開形區(qū)起始低，高位
  514.                 no_parameter(0xb0);                                                                                          //連續(xù)寫命令
  515.                 for(i=30*64;i>0;i--)                                                                                  //循環(huán)
  516.                 {
  517.                         check_sta03();                                                                                          //測連續(xù)寫忙
  518.                         wrdate(vlue);                                                                                          //寫入vlue值
  519.                 }
  520.                 check_sta03();                                                                                                  //測忙
  521.                 wrcomm(0xb2);                                                                                                  // 關(guān)閉連續(xù)寫
  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;                                                        //把結(jié)果低位賦給低變量
  533.         high=(temp>>8)&0x00ff;                                                //把結(jié)果高位給高變量
  534.         double_parameter(low,high,0x24);                        //寫入文本起始位置
  535.         no_parameter(0xb0);                                                        //連續(xù)寫命令
  536.         check_sta03();                                                                //測忙
  537.         wrdate(*addr);                                                                //寫入字符地址指針
  538.         check_sta03();                                                                //測連續(xù)寫忙
  539.         wrcomm(0xb2);                                                           //關(guān)閉連續(xù)寫
  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;                     //取出低位數(shù)據(jù)
  549.         graphic_startaddr_h=(temp>>8)&0x00ff;
  550.         double_parameter(graphic_startaddr_l,graphic_startaddr_h,0x24);//寫入圖形首地址
  551.         no_parameter(0xb0);                                                                        //連續(xù)寫命令
  552.         for(m=240;m>0;m--)                                                                        //循環(huán)行數(shù)
  553.         {
  554.                 for(n=30;n<0;n--)                                                                //每字節(jié)8位，列數(shù)/8
  555.                 {
  556.                         check_sta03();                                                                //測忙
  557.                         wrdate(* p++);                                                                //寫入圖形指針，然后加1地址
  558.                 }
  559.         }
  560.     check_sta03();                                                                                 //測忙
  561.         wrcomm(0xb2);                                                                             //關(guān)閉連續(xù)寫
  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;          //把字的坐標(biāo)地址賦給變量
  571.         low=temp&0x00ff;                                  //取出坐標(biāo)低位數(shù)值
  572.         high=(temp>>8)&0x00ff;                          //右移8位取出坐標(biāo)高位數(shù)值
  573.         double_parameter(low,high,0x24);   //寫入漢字坐標(biāo)
  574.         no_parameter(0xb0);                                  //開連續(xù)寫
  575.         check_sta03();                                          //測忙
  576.         wrdate(addr);                                          //寫入漢字左上4分之1
  577.         check_sta03();                                          //測試忙
  578.         wrdate(addr+2);                                          //寫入漢字右上4分之1
  579.         check_sta03();                                          //測忙
  580.         wrcomm(0xb2);                                      //關(guān)閉連續(xù)寫
  581.         delay(1);
  582.         temp=30*2*(hang-1)+30+(lie-1)*2;          //重新計算漢字坐標(biāo)也就是寫下部份，地址加一行（8*8）
  583.         low=temp&0x00ff;                                  //取出低位數(shù)值給變量
  584.         high=(temp>>8)&0x00ff;                          //右移8位取出高位給變量
  585.         double_parameter(low,high,0x24);   //寫入新起始地址（寫漢字下部份）
  586.         no_parameter(0xb0);                                  //連續(xù)寫命令
  587.         check_sta03();                                          //測忙
  588.         wrdate(addr+1);                                          //寫入漢字左下4分之1
  589.         check_sta03();                                          //測忙
  590.         wrdate(addr+3);                                          //寫入漢字右下4分之1
  591.         check_sta03();                                          //測忙
  592.         wrcomm(0xb2);                                      //關(guān)閉連續(xù)寫
  593. }

  595. /******************************自定義漢字寫入CGRAM***************************************/
  596. void cgram()
  597. {
  598.         uint m=0;                                                        //定義變量
  599.         double_parameter(0x07,0x00,0x22);        //設(shè)定最高的1K為CGRAM  寄存器偏移設(shè)定
  600.         double_parameter(0x00,0x3c,0x24);        //
  601.         no_parameter(0xb0);                                   //開連續(xù)寫
  602.         for(m=0;m<896+32;m++)                                //循環(huán)
  603.         {
  604.                 check_sta03();                                   //測忙
  605.                 wrdate(cgtab[m]);                                //寫入數(shù)據(jù)         
  606.         }
  607.         check_sta03();                                           //測忙
  608.         wrcomm(0xb2);                                                //關(guān)閉連續(xù)寫
  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. /****************************中斷函數(shù)*********************************/
  624. void t0time()interrupt 1
  625. {
  626.         TH0=(65536-5000)/256;                                         //重新賦值高位
  627.         TL0=(65536-5000)%256;                                         //重新賦值低位
  628.         t++;                                                                         //變量加
  629.         if(t==1000)                                                                 //變量計數(shù)到
  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;                                                                //拉低液晶屏復(fù)位腳
  686.         nop();                                                                //延時
  687.         nop();                                                                //延時
  688.         nop();                                                                //延時
  689.         rst=1;                                                                //拉高電平置位
  690.         text_size=graphic_size=30*64;                //文本和圖形區(qū)寬度
  691.         text_startaddr=0x0000;                            //文本區(qū)首地址
  692.         text_startaddr_l=text_startaddr;          //文本首地址低位
  693.         text_startaddr_h=text_startaddr>>8;          //文本首地址高位

  695.         graphic_startaddr=text_startaddr+text_size;         //圖形區(qū)首地址
  696.         graphic_startaddr_l=graphic_startaddr;                 //圖形區(qū)首地址低位
  697.         graphic_startaddr_h=graphic_startaddr>>8;         //圖形區(qū)首地址高位

  699.         double_parameter(text_startaddr_l,text_startaddr_h,0x40);        //寫入文本首地址
  700.         double_parameter(30,0x00,0x41);                                                                //寫入文本區(qū)長度（一行幾個字節(jié)）
  701.         double_parameter(graphic_startaddr_l,graphic_startaddr_h,0x42);          //寫入圖形區(qū)首地址
  702.         double_parameter(30,0x00,0x43);                                                                                //寫入圖形區(qū)長度（一行幾個字節(jié)）
  703.                                                                                                                                  
  704.         no_parameter(0x80);                 //文本 或 圖形
  705.         no_parameter(0x98);                 //圖形開文本關(guān)
  706.         all_display(1,0xff);          //表屏全亮
  707.         delay(5000);                         //延時
  708.         no_parameter(0xa7);                 //顯示8行光標(biāo)
  709.         no_parameter(0x94);                 //文本開圖形關(guān)
  710.     cgram();                                   //把字模寫入顯示屏自定義的CGRAM里
  711.           all_display(0,0x00);         //把文本區(qū)全顯示白
  712.            
  713. }

  715. /***********123123************寫入DS1302年，月，日，時分?jǐn)?shù)據(jù)****************************/
  716. void write1302()
  717. {
  718.    
  719.         write_ad_dat(0x8e,0x00);                   //關(guān)閉寫保護
  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. /****************************時間調(diào)節(jié)程序***********************************************/
  731. void time_tz()
  732. {
  733.     uint z;                                                                                        //        定義變量
  734.         uchar s,g;                                                                                // 變量十位，個位，高位，低位
  735.    while(flag)                                                                                //如果#按下表示要調(diào)節(jié)
  736.                                                            
  737.         {        
  738.             if(next==0)                                                                 //調(diào)節(jié)年十位標(biāo)志
  739.                 {
  740.                     write_ad_dat(0x8e,0x00);                 //關(guān)閉寫保護
  741.                 write_ad_dat(wds1302_sec,0x80);                //暫停1302
  742.                     buf[0]&=0x0f;                                                    //清空年十位，變成0000
  743.                     buf[0]|=key_scan()<<4;                                    //鍵盤返回值左移4位變高位或上數(shù)組高位
  744.                     if(yx)next=1;
  745.                       write_ad_dat(wds1302_year,buf[0]);                  //寫年數(shù)據(jù)                                                         
  746.                     read1302display();                                                  //讀出1302中數(shù)據(jù)
  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;                                                                                 //標(biāo)志位有效（就是有按鍵按下）
  751.                  }                                                                                                 //清除按鍵有效標(biāo)志位

  753.                 if(next==1)                                                                         //調(diào)節(jié)年個位標(biāo)志
  754.                 {                                                                                                
  755.                         buf[0]&=0xf0;                                                                  //清空年個位，變成0000
  756.                     buf[0]|=key_scan();                                                  //鍵盤返回值或上數(shù)組
  757.                     if(yx)next=2;                                                                  //如果如果按鍵標(biāo)志位為有效，使調(diào)標(biāo)志到下一調(diào)節(jié)位
  758.                       write_ad_dat(wds1302_year,buf[0]);                      //寫年數(shù)據(jù)                                                         
  759.                     read1302display();                                                                //讀1302中數(shù)據(jù)供顯示
  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;                                                                                        //清除鍵盤有效標(biāo)志位
  764.                 }

  766.                 if(next==2)                                                                           //月十位調(diào)節(jié)標(biāo)志
  767.                 {
  768.                     buf[1]&=0x0f;                                                                  //清空月十位，變成0000
  769.                     if((1>=key_scan())&yx)                                       //測試鍵盤輸入數(shù)小于等于1和輸入有效都為1
  770.                           {
  771.                                  buf[1]|=key<<4;                                                  //鍵盤返回值左移4位變高位或上數(shù)組高位
  772.                          next=3;                                                                  //使調(diào)節(jié)標(biāo)志位到月個位有效
  773.                                 }
  774.                       write_ad_dat(wds1302_month,buf[1]);                   //寫月                                                         
  775.                     read1302display();                                                                //讀出1302中數(shù)據(jù)供顯示
  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;                                                                                        //清除鍵盤輸入數(shù)值有效位
  780.                  }

  782.                 if(next==3)                                                                                //月個位調(diào)節(jié)標(biāo)志
  783.                 {
  784.                         buf[1]&=0xf0;                                                                  //清空月個位，變成0000
  785.                     if((2>=key_scan())&yx)                                                  //測試輸入值小于等于2和輸入有效
  786.                           {
  787.                            buf[1]|=key;                                                      //鍵盤返回值或上數(shù)組（給數(shù)組賦值）
  788.                        next=4;                                                                          //使調(diào)節(jié)標(biāo)志位到小時調(diào)節(jié)
  789.                           }
  790.                       write_ad_dat(wds1302_month,buf[1]);                  //寫月                                                         
  791.                     read1302display();                                                          //讀1302數(shù)據(jù)
  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)                                                                           //日十位調(diào)節(jié)標(biāo)志
  799.                 {
  800.                     buf[2]&=0x0f;                                                                  //清空日十位，變成0000
  801.                     if((3>=key_scan())&yx)                                       //如果輸入值小于等于3和鍵盤輸入地為1
  802.                           {
  803.                                  buf[2]|=key<<4;                                                  //鍵盤返回值左移4位變高位或上數(shù)組高位
  804.                          next=5;                                                                  //使調(diào)節(jié)標(biāo)志位到日個位
  805.                                 }
  806.                       write_ad_dat(wds1302_date,buf[2]);                      //寫日數(shù)據(jù)                                                         
  807.                     read1302display();                                                          //讀出1302數(shù)據(jù)
  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)                                                                          //日個位調(diào)節(jié)標(biāo)志
  815.                 {
  816.                         buf[2]&=0xf0;                                                                  //清空日個位，變成0000
  817.                     if((9>=key_scan())&yx)                                                //如果輸入值小于等于9和輸入有效都為1
  818.                           {
  819.                            buf[2]|=key;                                                    //鍵盤返回值或上數(shù)組
  820.                        next=6;                                                                        //使調(diào)節(jié)標(biāo)志為時十位有效
  821.                                 if(buf[2]>0x31)next=4;                                        //如果輸入的日數(shù)據(jù)大于31天，回到日十位重新輸入
  822.                           }
  823.                       write_ad_dat(wds1302_date,buf[2]);                     //寫日數(shù)據(jù)                                                         
  824.                     read1302display();                                                         //讀出1302中數(shù)據(jù)
  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;                                                                                  //清除鍵盤輸入有效標(biāo)志
  829.                 }

  831.                 if(next==6)                                                                          //小時調(diào)節(jié)標(biāo)志
  832.                 {
  833.                     buf[3]&=0x0f;                                                                  //清空時十位，變成0000
  834.                     if((2>=key_scan())&yx)                                       //如果輸入的值小于等于2，和鍵盤輸入有效
  835.                           {
  836.                                  buf[3]|=key<<4;                                                  //鍵盤返回值左移4位變高位或上數(shù)組高位
  837.                          next=7;                                                                  //使調(diào)節(jié)標(biāo)志位以小時的個位
  838.                                 }
  839.                       write_ad_dat(wds1302_hr,buf[3]);                      //寫小時數(shù)據(jù)                                                         
  840.                     read1302display();                                                          //讀1302數(shù)據(jù)
  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)                                                                         //小時個位調(diào)節(jié)標(biāo)志
  848.                 {
  849.                         buf[3]&=0xf0;                                                                 //清空時個位，變成0000
  850.                     if((9>=key_scan())&yx)                                                 //輸入值和輸入有效都為1
  851.                           {
  852.                            buf[3]|=key;                                                     //鍵盤返回值或上數(shù)組
  853.                        next=8;                                                                         //調(diào)節(jié)標(biāo)志位到分十位
  854.                                 if(buf[3]>=0x24)next=6;                                         //如果輸入的數(shù)值大于24，返回時十位重新輸入
  855.                           }
  856.                       write_ad_dat(wds1302_hr,buf[3]);                      //寫時數(shù)據(jù)                                                         
  857.                     read1302display();                                                          //讀1302中數(shù)據(jù)
  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;                                                                                  //清除鍵盤輸入有效標(biāo)志位
  862.                 }

  864.                 if(next==8)                                                                           //分十位調(diào)節(jié)標(biāo)志
  865.                 {
  866.                     buf[4]&=0x0f;                                                                  //清空分十位，變成0000
  867.                     if((5>=key_scan())&yx)                                       //輸入值小于等于5和鍵盤輸入都有效
  868.                           {
  869.                                  buf[4]|=key<<4;                                                  //鍵盤返回值左移4位變高位或上數(shù)組高位
  870.                          next=9;                                                                  //調(diào)節(jié)標(biāo)志位到分個位
  871.                                 }
  872.                       write_ad_dat(wds1302_min,buf[4]);                      //寫分?jǐn)?shù)據(jù)                                                         
  873.                     read1302display();                                                          //讀1302中數(shù)據(jù)
  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;                                                                                  //清除鍵盤輸入有效標(biāo)志位
  878.                  }

  880.                 if(next==9)                                                                          //分個位調(diào)節(jié)標(biāo)志
  881.                 {
  882.                         buf[4]&=0xf0;                                                                  //清空分個位，變成0000
  883.                     if((9>=key_scan())&yx)                                                  //輸入值小于等于9和輸入標(biāo)志都有效
  884.                           {
  885.                            buf[4]|=key;                                                     //鍵盤返回值或上數(shù)組
  886.                        next=10;                                                                 //調(diào)節(jié)標(biāo)志位到秒十位
  887.                           }
  888.                       write_ad_dat(wds1302_min,buf[4]);                     //寫分?jǐn)?shù)據(jù)                                                         
  889.                     read1302display();                                                         //讀1302中數(shù)據(jù)
  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;                                                                                        //清除鍵盤輸入有效標(biāo)志位
  894.                 }

  896.                 if(next==10)                                                                                 //秒十位調(diào)節(jié)標(biāo)志
  897.                 {
  898.                     buf[5]&=0x0f;                                                                  //清空秒十位，變成0000
  899.                     if((5>=key_scan())&yx)                                       //輸入值小于等于5和輸入有效都為1
  900.                           {
  901.                                  buf[5]|=key<<4;                                                  //鍵盤返回值左移4位變高位或上數(shù)組高位
  902.                          next=11;                                                                  //調(diào)節(jié)標(biāo)志位到秒個位
  903.                                 }
  904.                       write_ad_dat(wds1302_sec,buf[5]);                      //寫秒數(shù)據(jù)                                                         
  905.                     read1302display();                                                          //讀1302中數(shù)據(jù)
  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;                                                                                  //清除鍵盤輸入有效標(biāo)志位
  910.                  }

  912.                 if(next==11)                                                                          //秒個位調(diào)節(jié)標(biāo)志
  913.                 {
  914.                         buf[5]&=0xf0;                                                                  //清空秒個位，變成0000
  915.                     if((9>=key_scan())&yx)                                                  //輸入值小于等于9和輸入有效都為1
  916.                           {
  917.                            buf[5]|=key;                                                      //鍵盤返回值或上數(shù)組
  918.                        next=0;                                                                          //使調(diào)節(jié)標(biāo)志位到年十位，為下一次調(diào)節(jié)做準(zhǔn)備
  919.                                 flag=0;                                                                          //清除調(diào)節(jié)模式，回到正常顯示狀態(tài)
  920.                                 write_ad_dat(ds1302_control,0x80);              //開1302寫保護
  921.                           }
  922.                       write_ad_dat(wds1302_sec,buf[5]);                      //寫分?jǐn)?shù)據(jù)                                                         
  923.                     read1302display();                                                          //讀出1302中數(shù)據(jù)
  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;                                                                                        //清除鍵盤輸入有效標(biāo)志
  928.                 }
  929.         }
  930. }

  932. /****************123123****讀出1302數(shù)據(jù)并顯示**************************************/
  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++)                                                                  //把原始數(shù)據(jù)給顯示數(shù)組
  970.         {
  971.                 buf[i]=time_buf1[i];                                                  //常量數(shù)組數(shù)據(jù)賦給變量數(shù)組
  972.         }
  973.         write1302();                                                                          //寫入年，月日時，時間數(shù)據(jù)
  974.         while(1)
  975.         {
  976.              key_scan();                                                                          //  鍵盤掃描
  977.                 time_tz();                                                                          //  時間調(diào)整
  978.                 read1302display();                                                          //讀1302數(shù)據(jù)并顯示                                 
  979.         }      
  980. }        
復(fù)制代碼




lcd240×64液晶屏驅(qū)動.rar

52.03 KB, 下載次數(shù): 41, 下載積分: 黑幣 -5

分享到:  QQ好友和群QQ好友和群 QQ空間QQ空間 騰訊微博騰訊微博 騰訊朋友騰訊朋友
收藏收藏1 分享淘帖 頂頂 踩踩
回復(fù)

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規(guī)則

小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術(shù)交流QQ群281945664

Powered by 單片機教程網(wǎng)

快速回復(fù) 返回頂部 返回列表