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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › RTC实时时钟DS1302液晶显示单片机源程序
返回列表 发新帖
查看: 3629|回复: 0
打印 上一主题 下一主题
收起左侧

RTC实时时钟DS1302液晶显示单片机源程序

[复制链接]
跳转到指定楼层
楼主
ID:191441 发表于 2017-5-12 14:00 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
RTC实时时钟DS1302液晶显示 ds18b20


单片机源程序如下:
  1. /*-----------------------------------------------
  2.   名称：LCD1602显示实时时钟
  3.   修改：无
  4.   内容：音乐闹钟  普通闹钟已被注释    音乐闹钟无法停止 自动播放后停止 （普通闹钟功能正常）
  5.         error：无
  6.         warning：四个 函数未被调用
  7.   -----------------------------------------------*/
  8. #include<reg52.h>
  9. #include <String.h>
  10. #include"ds1302.h"
  11. #include"LCD1602.h"
  12. #include"key.h"
  13. #include "18B20.h"
  14. #include "240c02.h"         


  17. sbit buzeer = P2^3;           //普通闹钟

  19. sbit led1 =P2^4;              //指示灯
  20. sbit led2 =P2^5;
  21. sbit led3 =P2^6;
  22.        
  23. sbit fm=P2^3;                  //音乐闹钟 接口相同


  26. unsigned char timeh,timel,music;//            闹钟变量

  28. unsigned char code zbjbxf[]={//
  29. 0x64,0xA3,0xC1,0xA2,0x62,0x84,0x61,0x81,0x61,0xA4,0xA1,
  30. 0x91,0xA1,0x81,0x64,0xA3,0xC1,0xD2,0xD2,0xD2,0xA2,0xC4,
  31. 0xA1,0xC1,0xA1,0xC1,0xD2,0xD2,0xD2,0xA2,0xC4,0xC2,0x62,
  32. 0xC2,0x62,0xA2,0xA2,0x84,0x94,0x94,0x92,0x81,0x91,
  33. 0xA2,0xC2,0xD4,0xE4,0xA4,0xE4,0xA2,0xE2,0xA2,0xE2,0xA2,
  34. 0xA2,0x84,0x94,0x94,0x92,0x81,0x91,0xA2,0xC2,0xD8};

  36. uchar code chuzhi[]={
  37.          0xff,0xff,//
  38.          0xFC,0x8E,//L1-7
  39.          0xFC,0xED,       
  40.          0xFD,0x43,       
  41.          0xFD,0x6A,       
  42.          0xFD,0xB3,       
  43.          0xFD,0xF3,       
  44.          0xFE,0x2D,
  45.          0xFE,0x47,//H1-7          
  46.          0xFE,0x76,
  47.          0xFE,0xA1,
  48.          0xFE,0xC7,       
  49.          0xFE,0xD9,
  50.          0xFE,0xF9,
  51.          0xFF,0x16
  52.          };

  54. void timer0() interrupt 1         //音乐闹钟中断
  55. {
  56.         TH0=timeh;       
  57.         TL0=timel;        
  58.         fm=~fm;        
  59. }


  62. void delay(uint z)        //??165MS,??????
  63. {        uint y;
  64.         for(z;z>0;z--)
  65.                  for(y=19000;y>0;y--);//????
  66. }
  67. void delay1(uint z)        //??1MS
  68. {        uint y;
  69.         for(z;z>0;z--)
  70.                  for(y=112;y>0;y--);//????
  71. }



  75. //sbit bell = P2^3;
  76. char key;
  77. char keyflg;
  78. //时钟变量

  80. unsigned char times[7]={1};
  81. unsigned char time[3];
  82. unsigned char PPP;

  84. unsigned char clock_buf[7];
  85. //闹钟变量
  86. unsigned char counter;
  87. unsigned char baifenmiao;
  88. unsigned char shifenmiao;
  89. unsigned char miao;
  90. unsigned char shimiao;
  91. unsigned char baimiao;


  94. void key_timeset(void);
  95. void dateTrans(void);
  96. void alarm_aclok(void);
  97. void arm(void);
  98. void timer_run(void);
  99. void timer_runback(void);
  100. void clock_display(void);
  101. void clock_delay(void);
  102. void start(void);
  103. void delay_ms(unsigned int z);
  104. void ds18b20(void);
  105. void ds18b20_xiugai(void);
  106. void xieshuju(void);
  107. void dushuju(void);
  108.        
  109. void buzeer_music()                    //音乐闹钟
  110. {
  111.         uint temp;        //??????????????????
  112.         uchar i=0;       
  113.         uchar jp;        //jp????temp???8???8?
  114.         TMOD=0x01;//?????T0?????1
  115.         IE=0x82;  //??T0??
  116.         while(music)
  117.         {
  118.                                         /*        ds1302_read_time();//读取时钟信息
  119.                                        
  120.                                                 dateTrans();         //数据复制
  121.                                                 disp();*/
  122.                 key = Key4Scan();
  123.                 if(key==4){cflg=1; keyflg=0;music=0;}       
  124.                 if(key==6){ keyflg=0;}       
  125.                 clock_delay();
  126.                
  127.                
  128.                 temp=zbjbxf[i];
  129.                 if(temp==0xff)
  130.                         break;       
  131.                 jp=temp/16; //????4?,????
  132.                 if(jp!=0)
  133.                 {
  134.                 timeh=chuzhi[jp*2];//????????8?
  135.                 timel=chuzhi[jp*2+1]; //????????8?
  136.                 TR0=1;          //????
  137.                 }
  138.                 else
  139.                 {
  140.                 TR0=0;          //????
  141.                 fm=1;          //????
  142.                 }
  143.                 delay(temp%16); //????4?,??(?????)
  144.                 TR0=0;         //??????5MS
  145.                 fm=1;
  146.                 delay1(5);
  147.                 //TR0=1;
  148.                 i++;
  149.         }
  150.         /*TR0=0;        //????
  151.         fm=1;        //????*/                //JJX
  152. }
  153. void Time1_Int(){          //用于定时 倒计时
  154.                 TMOD=0x10;
  155.                 TH1=0xfc;          //10毫秒
  156.                 TL1=0x66;
  157.                 EA=1;
  158.                 ET1=1;
  159.                 TR1=1;
  160. }

  162. void main()
  163. {
  164.                          //buzeer=0;        //闹钟停         
  165.                                 buzeer=1;                                // 接非门后闹钟停
  166.                         // dushuju(); //e2prom 读数据 有问题
  167.                          ds1302_init(); /*DS302初始化函数*/
  168.        
  169.        ds1302_write_time();      
  170.                          ds1302_read_time();
  171.                         // tmpchange();
  172.                          //Time0_Int();
  173.        InitLcd();     //初始化LCD
  174.        DelayMs(15);   //延时用于稳定功能
  175.                          Time1_Int();
  176.                          start();                //开机显示

  178.                          
  179.   while(1)
  180.         {
  181.                                 key = Key4Scan();       
  182.                     if(!cflag){
  183.                                
  184.                                                 if(key==4) { buzeer= 1;/*buzeer= 0;*/}               //按键停止闹钟
  185.                                         //        while(1);              //调试
  186.                                                 alarm_aclok();                                         //闹钟
  187.                                                
  188.                                                 ds1302_read_time();//读取时钟信息
  189.                                        
  190.                                                 dateTrans();         //数据复制
  191.                                                 disp();         //液晶显示时间信息
  192.                                                 timer_run();         //秒表
  193.                                                 timer_runback();                //倒计时
  194.                                                 clock_display();                //时钟显示
  195.                                                 if(key==7) keyflg=7;       
  196.                                                 ds18b20();                                        //按键显示
  197.                                         //        ds18b20_xiugai();               // 显示位置修改
  198.                                                 if(key==4) keyflg=0;
  199.                                                 if(key==5) keyflg=5;
  200.                                                 if(key==6) keyflg=6;
  201.                                        
  202.                                                                        
  203.                                                 clock_delay();                  //瞌睡
  204.                                                 xieshuju();                   // ——>到e2prom         
  205.                                         //        WriteCommand(0x80+0x40+15); //按键调试信息
  206.                                         //        WriteData(shuzi[key]);       
  207.                                 }
  208.                                 key_timeset();           //案件时间设定               
  209.                         }
  210.                          
  211. }











  223. void key_timeset(void){
  224.         char i;
  225.                 switch(key)   //Key4Scan()
  226.                         {
  227.                                                 case 0x01:
  228.                                                                                                 switch(PP++)      //??????
  229.                                                                                                 {
  230.                                                                                                 case 0:  WriteCommand(0x80+0x40+7);break;                                                //秒
  231.                                                                                                 case 1:  WriteCommand(0x80+3);break;            //年
  232.                                                                                                 case 2:  WriteCommand(0x80+6);break;                                                //月
  233.                                                                                                 case 3:  WriteCommand(0x80+9);break;                                //日
  234.                                                                                                 case 4:  WriteCommand(0x80+15);break;                                //周
  235.                                                                                                 case 5:  WriteCommand(0x80+0x40+1);break;                                //时
  236.                                                                                                 case 6:  WriteCommand(0x80+0x40+4);break;                                //分
  237.                                                                                                 default:break;
  238.                                                                                                 }                  
  239.                                                                                                 WriteCommand(0x0f);//光标闪烁
  240.                                                                                                 if(PP == 8) PP = 0;                 //7还是 8好像和编译器有关系
  241.                                                                                                
  242.                                                                                                 cflag = 1;          //????
  243.                                                                                                
  244.                                                                                                 break;
  245.                                                 case 0x02:
  246.                                                                                                 if(cflag)
  247.                                                                                                 {
  248.                                                                                                                 switch(PP-1)
  249.                                                                                                                 {
  250.                                                                                                                 case 1:          // 年                                       
  251.                                                                                                                                                 times[6]++;
  252.                                                                                                                                                 if((times[6]&0x0f) == 0x0a)                   //  0000 1111 1010  转变为16进制
  253.                                                                                                                                                 {
  254.                                                                                                                                                                 times[6] += 0x06;      
  255.                                                                                                                                                 }
  256.                                                                                                                                                 if(times[6] > 0x99)
  257.                                                                                                                                                 {
  258.                                                                                                                                                                 times[6] = 0x00;   
  259.                                                                                                                                                 }
  260.                                                                                                                                         WriteCommand(0x80+2);
  261.                                                                                                                                         WriteData(shuzi[times[6]>>4]);
  262.                                                                                                                                         WriteData(shuzi[times[6]&0x0f]);
  263.                                                                                                                                         WriteCommand(0x80+3);
  264.                                                                                                                                         break;
  265.                                                                                                                 case 2:                                 //月
  266.                                                                                                                                                 times[4]++;
  267.                                                                                                                                                 if((times[4]&0x0f) == 0x0a)
  268.                                                                                                                                                 {
  269.                                                                                                                                                                 times[4] += 0x06;      
  270.                                                                                                                                                 }
  271.                                                                                                                                                 if(times[4] > 0x12)
  272.                                                                                                                                                 {
  273.                                                                                                                                                                 times[4] = 0x01;   
  274.                                                                                                                                                 }
  275.                                                                                                                                                 WriteCommand(0x80+5);
  276.                                                                                                                                                 WriteData(shuzi[times[4]>>4]);
  277.                                                                                                                                                 WriteData(shuzi[times[4]&0x0f]);
  278.                                                                                                                                                 WriteCommand(0x80+6);
  279.                                                                                                                                                 break;
  280.                                                                                                                 case 3:                        //
  281.                                                                                                                                                 times[3]++;
  282.                                                                                                                                                 if((times[3]&0x0f) == 0x0a)
  283.                                                                                                                                                 {
  284.                                                                                                                                                                 times[3] += 0x06;      
  285.                                                                                                                                                 }
  286.                                                                                                                                                 if(times[3] > 0x31)
  287.                                                                                                                                                 {
  288.                                                                                                                                                                 times[3] = 0x01;   
  289.                                                                                                                                                 }
  290.                                                                                                                                                 times[5]++;
  291.                                                                                                                                                 if((times[5]&0x0f) == 0x08)
  292.                                                                                                                                                 {
  293.                                                                                                                                                                 times[5] = 0x01;      
  294.                                                                                                                                                 }
  295.                                                                                                                                                 WriteCommand(0x80+8);
  296.                                                                                                                                                 WriteData(shuzi[times[3]>>4]);
  297.                                                                                                                                                 WriteData(shuzi[times[3]&0x0f]);
  298.                                                                                                                                                 WriteCommand(0x80+9);
  299.                                                                                                                                        
  300.                                                                                                                                                 break;
  301.                                                                                                                  case 4:         //?
  302.                                                                                                                                          times[5]++;
  303.                                                                                                                                                 if((times[5]&0x0f) == 0x08)
  304.                                                                                                                                                 {
  305.                                                                                                                                                                 times[5] = 0x01;      
  306.                                                                                                                                                 }
  307.                                                                                                                                                 WriteCommand(0x80+15);
  308.                                                                                                                                                 WriteData(shuzi[times[5]]);
  309.                                                                                                                                                 WriteCommand(0x80+15);
  310.                                                                                                                                        
  311.                                                                                                                                                 break;
  312.                                                                                                                  case 5:         //?
  313.                                                                                                                                                 times[2]++;
  314.                                                                                                                                                 if((times[2]&0x0f) == 0x0a)
  315.                                                                                                                                                 {
  316.                                                                                                                                                                 times[2] += 0x06;      
  317.                                                                                                                                                 }
  318.                                                                                                                                                 if(times[2] > 0x23)
  319.                                                                                                                                                 {
  320.                                                                                                                                                                 times[2] = 0x00;   
  321.                                                                                                                                                 }
  322.                                                                                                                                                 WriteCommand(0x80+0x40+0);
  323.                                                                                                                                                 WriteData(shuzi[times[2]>>4]);
  324.                                                                                                                                                 WriteData(shuzi[times[2]&0x0f]);
  325.                                                                                                                                                 WriteCommand(0x80+0x40+1);
  326.                                                                                                                
  327.                                                                                                                                                 break;
  328.                                                                                                                  case 6:         //?
  329.                                                                                                                                                 times[1]++;
  330.                                                                                                                                                 if((times[1]&0x0f) == 0x0a)
  331.                                                                                                                                                 {
  332.                                                                                                                                                                 times[1] += 0x06;      
  333.                                                                                                                                                 }
  334.                                                                                                                                                 if(times[1] > 0x59)
  335.                                                                                                                                                 {
  336.                                                                                                                                                                 times[1] = 0x00;   
  337.                                                                                                                                                 }
  338.                                                                                                                                                 WriteCommand(0x80+0x40+3);
  339.                                                                                                                                                 WriteData(shuzi[times[1]>>4]);
  340.                                                                                                                                                 WriteData(shuzi[times[1]&0x0f]);
  341.                                                                                                                                                 WriteCommand(0x80+0x40+4);
  342.                                                                                                                                
  343.                                                                                                                                                 break;
  344.                                                                                                                  case 0:         //?
  345.                                                                                                                                                 times[0]++;
  346.                                                                                                                                                 if((times[0]&0x0f) == 0x0a)
  347.                                                                                                                                                 {
  348.                                                                                                                                                                 times[0] += 0x06;      
  349.                                                                                                                                                 }
  350.                                                                                                                                                 if(times[0] > 0x59)
  351.                                                                                                                                                 {
  352.                                                                                                                                                                 times[0] = 0x00;   
  353.                                                                                                                                                 }
  354.                                                                                                                                                 WriteCommand(0x80+0x40+6);
  355.                                                                                                                                                 WriteData(shuzi[times[0]>>4]);
  356.                                                                                                                                                 WriteData(shuzi[times[0]&0x0f]);
  357.                                                                                                                                                 WriteCommand(0x80+0x40+7);
  358.                                                                                                                                        
  359.                                                                                                                                                 break;
  360.                                                                                                                 default:
  361.                                                                                                                                                 break;                           
  362.                                                                                                                                                
  363.                                                                                                                 }
  364.                                                                                                 }
  365.                                                                                                 break;
  366.                                                 case 0x03:
  367.                                                                                                 if(cflag)
  368.                                                                                                 {
  369.                                                                                                                 cflag = 0;
  370.                                                                                                                 PP = 0;
  371.                                                                                                          WriteCommand(0X0C);   //取消 并关光标
  372.                                                                                                 }
  373.                                                                                                 break;
  374.                                                 case 0x04:                                 //保存数据到 DS1302
  375.                                                                                                 if(cflag)
  376.                                                                                                 {
  377.                                                                                                                 cflag = 0;
  378.                                                                                                                 PP = 0;
  379.                                                                                                          WriteCommand(0X0C);   //关光标
  380.                                                                                                         ds1302_write_byte(ds1302_control_add,0x00);                        //关闭写保护
  381.                                                                                                         ds1302_write_byte(ds1302_sec_add,0x80);                                //暂停
  382.                                                                                                         ds1302_write_byte(ds1302_charger_add,0xa9);                        //涓流充电
  383.                                                                                                        
  384.                                                                                                         ds1302_write_byte(ds1302_year_add,times[6]);                //年
  385.                                                                                                         ds1302_write_byte(ds1302_month_add,times[4]);        //月
  386.                                                                                                         ds1302_write_byte(ds1302_day_add,times[5]);                //周
  387.                                                                                                         ds1302_write_byte(ds1302_date_add,times[3]);                //日
  388.                                                                                                        
  389.                                                                                                         ds1302_write_byte(ds1302_hr_add,times[2]);                //时
  390.                                                                                                         ds1302_write_byte(ds1302_min_add,times[1]);                //分
  391.                                                                                                         ds1302_write_byte(ds1302_sec_add,times[0]);                //秒
  392.                                                                                                         ds1302_write_byte(ds1302_control_add,0x80);                        //打开写保护
  393.                                                                                                        
  394.                                                                                                          // Set_DS1302(times);   //DS1302 写入时间
  395.                                                                                                 }
  396.                                                                                                 break;
  397.                                                  case 0x05:            //保存数据到闹钟
  398.                                                                                                 if(cflag)
  399.                                                                                                 {
  400.                                                                                                                 cflag = 0;
  401.                                                                                                                 PP = 0;
  402.                                                                                                          WriteCommand(0X0C);   //关光标
  403.                                                                                                         for(i=0;i<7;i++){
  404.                                                                                                                                 clock_buf[i]=times[i];

  406.                                                                                                         }
  407.                                                                                                 //        strcpy(clock_buf,times);
  408.                                                                                                 }
  409.                                                                                                 break;
  410.                                                 default:
  411.                                                                                                 break;                    
  412.                         }
  413. }
  414. void dateTrans(void){
  415.        
  416.         times[6]=time_buf[1];
  417.         times[5]=time_buf[7];
  418.        
  419.         times[4]=time_buf[2];
  420.         times[3]=time_buf[3];
  421.         times[2]=time_buf[4];
  422.         times[1]=time_buf[5];
  423.         times[0]=time_buf[6];

  425. }
  426. void alarm_aclok(void)
  427.         {               
  428.                
  429.                 if((times[2]==clock_buf[2])&&(times[1]==clock_buf[1])&&(times[0]==0))        {/*buzeer= 0;*/        music=1;buzeer_music();/*可替换为普通闹钟*/}     //1111 0111 P2 & 0xf7
  430.                 //else        {        buzeer= 1;}
  431. }
  432.        
  433. void T1_time() interrupt 3 {

  435.                 TH1=0xfc;
  436.                 TL1=0x66;
  437.                 counter++;
  438.         if(counter == 10)                { counter = 0; baifenmiao++;}
  439.         if(baifenmiao == 10)                {baifenmiao = 0; shifenmiao++;}
  440.         if(shifenmiao == 10)                {shifenmiao = 0;led1=~led1; miao++;}
  441.         if(miao == 10)                { miao = 0; shimiao++;}
  442.         if(shimiao == 10)                { shimiao = 0; baimiao++;}
  443.         if(baimiao == 10) baimiao =0;
  444.        
  445. }

  447. void timer_run(void)
  448. {
  449.                 if(key==2) keyflg=2;                       //计时功能
  450.                 while(key==2)
  451.                                 {       
  452.                                                 WriteCommand(0x01); //显示清屏
  453.                                                 while(keyflg==2){
  454.                                                                         key = Key4Scan();
  455.                                                                         if(key==4) keyflg=0;
  456.                                                                         WriteCommand(0x80+5);            //计时功能
  457.                                                                         WriteData(shuzi[baimiao]);
  458.                                                                         WriteData(shuzi[shimiao]);
  459.                                                                         WriteData(shuzi[miao]);
  460.                                                                         WriteData('.');                               
  461.                                                                         WriteData(shuzi[shifenmiao]);
  462.                                                                         WriteData(shuzi[baifenmiao]);
  463.                                                         if(key==2) TR1=~TR1;
  464.                                                         if(key==3) {shifenmiao=0;baifenmiao=0;baimiao=0;shimiao=0;miao=0;TR0=0;}
  465.                                         }
  466.                                         WriteCommand(0x01); //显示清屏
  467.                                 }
  468. }
  469. void timer_runback(void){
  470.                 if(key==3) keyflg=3;                       //倒计时功能
  471.                 while(key==3)
  472.                         {
  473.                                 WriteCommand(0x01); //显示清屏
  474.                                 WriteCommand(0x80+5); //显示清屏   k1 功能选择 k2 定是数据选择 k3数据保存
  475.                                                 WriteData('0');
  476.                                                 WriteData('0');
  477.                                                 WriteData('0');
  478.                                         /*        WriteData(':');
  479.                                                 WriteData('0');
  480.                                                 WriteData('0');*/
  481.                                 while(keyflg==3)
  482.                                         {
  483.                                                 key = Key4Scan();
  484.                                                 if(key==4) keyflg=0;
  485.                                        
  486.                                                 switch(key)   //Key4Scan()
  487.                         {
  488.                                                 case 0x01:
  489.                                                                                                 switch(PPP++)      //??????
  490.                                                                                                 {
  491.                                                                                                 case 0:  WriteCommand(0x80+5);break;                                                //分钟
  492.                                                                                                 case 1:  WriteCommand(0x80+6);break;            //
  493.                                                                                                 case 2:  WriteCommand(0x80+7);break;                                                //
  494.                                                                                         /*case 3:  WriteCommand(0x80+9);break;                                //        秒
  495.                                                                                                 case 4:  WriteCommand(0x80+10);break;                                //*/
  496.                                                                                                 default:break;
  497.                                                                                                 }                  
  498.                                                                                                 WriteCommand(0x0f);//光标闪烁
  499.                                                                                                 if(PPP == 4){ PPP = 0; time[0]=time[1]=time[2] =0; }              //7还是 8好像和编译器有关系
  500.                                                                                                
  501.                                                                                                 cflg = 1;          //标志位
  502.                                                                                                
  503.                                                                                                 break;
  504.                                                 case 0x02:
  505.                                                                                                 if(cflg)
  506.                                                                                                 {
  507.                                                                                                                 switch(PPP-1)
  508.                                                                                                                 {
  509.                                                                                                                 case 0:          // 百秒                                       
  510.                                                                                                                                                 time[0]++;
  511.                                                                                                                                
  512.                                                                                                                                                 if(time[0] > 9)
  513.                                                                                                                                                 {
  514.                                                                                                                                                                 time[0] = 0;   
  515.                                                                                                                                                 }
  516.                                                                                                                                         WriteCommand(0x80+5);
  517.                                                                                                                                         WriteData(shuzi[time[0]]);
  518.                                                                                                                                         WriteCommand(0x80+5);
  519.                                                                                                                                         break;
  520.                                                                                                                 case 1:                                 //十秒
  521.                                                                                                                                                 time[1]++;
  522.                                                                                                                
  523.                                                                                                                                                 if(time[1] > 9)
  524.                                                                                                                                                 {
  525.                                                                                                                                                                 time[1] = 0;   
  526.                                                                                                                                                 }
  527.                                                                                                                                                 WriteCommand(0x80+6);
  528.                                                                                                                                                 WriteData(shuzi[time[1]]);
  529.                                                                                                                                                 WriteCommand(0x80+6);
  530.                                                                                                                                                 break;
  531.                                                                                                                 case 2:                        //秒
  532.                                                                                                                                                 time[2]++;
  533.                                                                                                                                                 if(time[2] > 9)
  534.                                                                                                                                                 {
  535.                                                                                                                                                                 time[2] = 0;   
  536.                                                                                                                                                 }
  537.                                                                                                                                                 WriteCommand(0x80+7);
  538.                                                                                                                                                 WriteData(shuzi[time[2]]);;
  539.                                                                                                                                                 WriteCommand(0x80+7);
  540.                                                                                                                                        
  541.                                                                                                                                                 break;
  542.                                        
  543.                                                                                                        
  544.                                                                                                                 default:
  545.                                                                                                                                                 break;                           
  546.                                                                                                                                                
  547.                                                                                                                 }
  548.                                                                                                 }
  549.                                                                                                 break;
  550.                                                 case 0x03:
  551.                                                                                                 if(cflg)
  552.                                                                                                 {
  553.                                                                                                                 cflg = 0;
  554.                                                                                                                 PPP = 0;
  555.                                                                                                          WriteCommand(0X0C);   //取消 并关光标
  556.                                                                                                                 miao=9-time[2];
  557.                                                                                                                 shimiao=9-time[1];
  558.                                                                                                                 baimiao=9-time[0];
  559.                                                                                        
  560.                                                                                                 }
  561.                                                                                                 break;
  562.                                  
  563.                                                 /* case 0x05:            //保存数据到闹钟
  564.                                                                                                 if(cflag)
  565.                                                                                                 {
  566.                                                                                                                 cflag = 0;
  567.                                                                                                                 PP = 0;
  568.                                                                                                          WriteCommand(0X0C);   //关光标

  570.                                                                                                 }
  571.                                                                                                 break; */
  572.                                                 default:
  573.                                                                                                 break;                    
  574.                         }
  575.                                 while(!cflg)       
  576.                                 {
  577.                                        
  578.                                                 WriteCommand(0X80+5);   //取消 并关光标               
  579.                                                 WriteData(shuzi[9-baimiao]);
  580.                                                 WriteData(shuzi[9-shimiao]);
  581.                                                 WriteData(shuzi[9-miao]);
  582.                                                 key = Key4Scan();
  583.                                                 if(key==4){cflg=1; keyflg=0; }
  584.                                                 while((9-baimiao)==0&&(9-shimiao==0)&&(9-miao)==0)
  585.                                                 {
  586.                                                                 while(keyflg){       
  587.                                                                         led3=~led3;
  588.                                                                         DelayMs(3500);
  589.                                                                         key = Key4Scan();
  590.                                                                         WriteCommand(0X80+7);
  591.                                                                         WriteData('0');
  592.                                                                         if(key==4){cflg=1; keyflg=0; }
  593.                                                                 }
  594.                                                 }

  596.                                 }
  597.                                         }
  598.                         WriteCommand(0X01);       
  599.                         }

  601. }

  603. void clock_display(void)
  604. {
  605.                 if(key==5)
  606.                 {
  607.                         WriteCommand(0x01);
  608.                         WriteCommand(0x80+5);
  609.                         WriteData(shuzi[clock_buf[2]/16]);
  610.                         WriteData(shuzi[clock_buf[2]%16]);
  611.                         WriteData(':');
  612.                         WriteData(shuzi[clock_buf[1]/16]);
  613.                         WriteData(shuzi[clock_buf[1]%16]);       
  614.                         delay_ms(2000);                
  615.                                                
  616.                                        
  617.                
  618.                 }
  619. }
  620. void clock_delay(void)
  621. {
  622.        
  623.                 if(key==6)
  624.                 {
  625.                         miao=0;
  626.                         shimiao=0;
  627.                         TR0=0;
  628.                         buzeer=1;
  629.                 }
  630.         if(keyflg==6)
  631.                         {
  632.                                         if(miao==9)
  633.                                 {
  634.                                                   
  635.                                                                 //buzeer=0;
  636.                                                         TR0=1;
  637.                                                         buzeer_music();
  638.                                 }
  639.                         }       

  641. }

  643. void start(void)
  644. {
  645.                
  646.        
  647.                 WriteCommand(0x80+3);
  648.           
  649.           WriteData('3');
  650.                 WriteData('-');
  651.           WriteData('0');
  652.                 WriteData('5');
  653.                 WriteData('-');
  654.                 WriteData('0');
  655.                 WriteData('6');

  657.        
  658.           led2=1;
  659.                 delay_ms(1000);        
  660. ……………………

  662. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
RTC实时时钟DS1302液晶显示.rar (96.15 KB, 下载次数: 24)


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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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