久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步,快速開始

搜索
查看: 3625|回復: 0
打印 上一主題 下一主題
收起左側

RTC實時時鐘DS1302液晶顯示單片機源程序

[復制鏈接]
跳轉到指定樓層
樓主
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"         


  15. sbit buzeer = P2^3;           //普通鬧鐘

  16. sbit led1 =P2^4;              //指示燈
  17. sbit led2 =P2^5;
  18. sbit led3 =P2^6;
  19.        
  20. sbit fm=P2^3;                  //音樂鬧鐘 接口相同


  21. unsigned char timeh,timel,music;//            鬧鐘變量

  22. unsigned char code zbjbxf[]={//
  23. 0x64,0xA3,0xC1,0xA2,0x62,0x84,0x61,0x81,0x61,0xA4,0xA1,
  24. 0x91,0xA1,0x81,0x64,0xA3,0xC1,0xD2,0xD2,0xD2,0xA2,0xC4,
  25. 0xA1,0xC1,0xA1,0xC1,0xD2,0xD2,0xD2,0xA2,0xC4,0xC2,0x62,
  26. 0xC2,0x62,0xA2,0xA2,0x84,0x94,0x94,0x92,0x81,0x91,
  27. 0xA2,0xC2,0xD4,0xE4,0xA4,0xE4,0xA2,0xE2,0xA2,0xE2,0xA2,
  28. 0xA2,0x84,0x94,0x94,0x92,0x81,0x91,0xA2,0xC2,0xD8};

  29. uchar code chuzhi[]={
  30.          0xff,0xff,//
  31.          0xFC,0x8E,//L1-7
  32.          0xFC,0xED,       
  33.          0xFD,0x43,       
  34.          0xFD,0x6A,       
  35.          0xFD,0xB3,       
  36.          0xFD,0xF3,       
  37.          0xFE,0x2D,
  38.          0xFE,0x47,//H1-7          
  39.          0xFE,0x76,
  40.          0xFE,0xA1,
  41.          0xFE,0xC7,       
  42.          0xFE,0xD9,
  43.          0xFE,0xF9,
  44.          0xFF,0x16
  45.          };

  46. void timer0() interrupt 1         //音樂鬧鐘中斷
  47. {
  48.         TH0=timeh;       
  49.         TL0=timel;        
  50.         fm=~fm;        
  51. }


  52. void delay(uint z)        //??165MS,??????
  53. {        uint y;
  54.         for(z;z>0;z--)
  55.                  for(y=19000;y>0;y--);//????
  56. }
  57. void delay1(uint z)        //??1MS
  58. {        uint y;
  59.         for(z;z>0;z--)
  60.                  for(y=112;y>0;y--);//????
  61. }



  62. //sbit bell = P2^3;
  63. char key;
  64. char keyflg;
  65. //時鐘變量

  66. unsigned char times[7]={1};
  67. unsigned char time[3];
  68. unsigned char PPP;

  69. unsigned char clock_buf[7];
  70. //鬧鐘變量
  71. unsigned char counter;
  72. unsigned char baifenmiao;
  73. unsigned char shifenmiao;
  74. unsigned char miao;
  75. unsigned char shimiao;
  76. unsigned char baimiao;


  77. void key_timeset(void);
  78. void dateTrans(void);
  79. void alarm_aclok(void);
  80. void arm(void);
  81. void timer_run(void);
  82. void timer_runback(void);
  83. void clock_display(void);
  84. void clock_delay(void);
  85. void start(void);
  86. void delay_ms(unsigned int z);
  87. void ds18b20(void);
  88. void ds18b20_xiugai(void);
  89. void xieshuju(void);
  90. void dushuju(void);
  91.        
  92. void buzeer_music()                    //音樂鬧鐘
  93. {
  94.         uint temp;        //??????????????????
  95.         uchar i=0;       
  96.         uchar jp;        //jp????temp???8???8?
  97.         TMOD=0x01;//?????T0?????1
  98.         IE=0x82;  //??T0??
  99.         while(music)
  100.         {
  101.                                         /*        ds1302_read_time();//讀取時鐘信息
  102.                                        
  103.                                                 dateTrans();         //數據復制
  104.                                                 disp();*/
  105.                 key = Key4Scan();
  106.                 if(key==4){cflg=1; keyflg=0;music=0;}       
  107.                 if(key==6){ keyflg=0;}       
  108.                 clock_delay();
  109.                
  110.                
  111.                 temp=zbjbxf[i];
  112.                 if(temp==0xff)
  113.                         break;       
  114.                 jp=temp/16; //????4?,????
  115.                 if(jp!=0)
  116.                 {
  117.                 timeh=chuzhi[jp*2];//????????8?
  118.                 timel=chuzhi[jp*2+1]; //????????8?
  119.                 TR0=1;          //????
  120.                 }
  121.                 else
  122.                 {
  123.                 TR0=0;          //????
  124.                 fm=1;          //????
  125.                 }
  126.                 delay(temp%16); //????4?,??(?????)
  127.                 TR0=0;         //??????5MS
  128.                 fm=1;
  129.                 delay1(5);
  130.                 //TR0=1;
  131.                 i++;
  132.         }
  133.         /*TR0=0;        //????
  134.         fm=1;        //????*/                //JJX
  135. }
  136. void Time1_Int(){          //用于定時 倒計時
  137.                 TMOD=0x10;
  138.                 TH1=0xfc;          //10毫秒
  139.                 TL1=0x66;
  140.                 EA=1;
  141.                 ET1=1;
  142.                 TR1=1;
  143. }

  144. void main()
  145. {
  146.                          //buzeer=0;        //鬧鐘停         
  147.                                 buzeer=1;                                // 接非門后鬧鐘停
  148.                         // dushuju(); //e2prom 讀數據 有問題
  149.                          ds1302_init(); /*DS302初始化函數*/
  150.        
  151.        ds1302_write_time();      
  152.                          ds1302_read_time();
  153.                         // tmpchange();
  154.                          //Time0_Int();
  155.        InitLcd();     //初始化LCD
  156.        DelayMs(15);   //延時用于穩定功能
  157.                          Time1_Int();
  158.                          start();                //開機顯示

  159.                          
  160.   while(1)
  161.         {
  162.                                 key = Key4Scan();       
  163.                     if(!cflag){
  164.                                
  165.                                                 if(key==4) { buzeer= 1;/*buzeer= 0;*/}               //按鍵停止鬧鐘
  166.                                         //        while(1);              //調試
  167.                                                 alarm_aclok();                                         //鬧鐘
  168.                                                
  169.                                                 ds1302_read_time();//讀取時鐘信息
  170.                                        
  171.                                                 dateTrans();         //數據復制
  172.                                                 disp();         //液晶顯示時間信息
  173.                                                 timer_run();         //秒表
  174.                                                 timer_runback();                //倒計時
  175.                                                 clock_display();                //時鐘顯示
  176.                                                 if(key==7) keyflg=7;       
  177.                                                 ds18b20();                                        //按鍵顯示
  178.                                         //        ds18b20_xiugai();               // 顯示位置修改
  179.                                                 if(key==4) keyflg=0;
  180.                                                 if(key==5) keyflg=5;
  181.                                                 if(key==6) keyflg=6;
  182.                                        
  183.                                                                        
  184.                                                 clock_delay();                  //瞌睡
  185.                                                 xieshuju();                   // ——>到e2prom         
  186.                                         //        WriteCommand(0x80+0x40+15); //按鍵調試信息
  187.                                         //        WriteData(shuzi[key]);       
  188.                                 }
  189.                                 key_timeset();           //案件時間設定               
  190.                         }
  191.                          
  192. }











  193. void key_timeset(void){
  194.         char i;
  195.                 switch(key)   //Key4Scan()
  196.                         {
  197.                                                 case 0x01:
  198.                                                                                                 switch(PP++)      //??????
  199.                                                                                                 {
  200.                                                                                                 case 0:  WriteCommand(0x80+0x40+7);break;                                                //秒
  201.                                                                                                 case 1:  WriteCommand(0x80+3);break;            //年
  202.                                                                                                 case 2:  WriteCommand(0x80+6);break;                                                //月
  203.                                                                                                 case 3:  WriteCommand(0x80+9);break;                                //日
  204.                                                                                                 case 4:  WriteCommand(0x80+15);break;                                //周
  205.                                                                                                 case 5:  WriteCommand(0x80+0x40+1);break;                                //時
  206.                                                                                                 case 6:  WriteCommand(0x80+0x40+4);break;                                //分
  207.                                                                                                 default:break;
  208.                                                                                                 }                  
  209.                                                                                                 WriteCommand(0x0f);//光標閃爍
  210.                                                                                                 if(PP == 8) PP = 0;                 //7還是 8好像和編譯器有關系
  211.                                                                                                
  212.                                                                                                 cflag = 1;          //????
  213.                                                                                                
  214.                                                                                                 break;
  215.                                                 case 0x02:
  216.                                                                                                 if(cflag)
  217.                                                                                                 {
  218.                                                                                                                 switch(PP-1)
  219.                                                                                                                 {
  220.                                                                                                                 case 1:          // 年                                       
  221.                                                                                                                                                 times[6]++;
  222.                                                                                                                                                 if((times[6]&0x0f) == 0x0a)                   //  0000 1111 1010  轉變為16進制
  223.                                                                                                                                                 {
  224.                                                                                                                                                                 times[6] += 0x06;      
  225.                                                                                                                                                 }
  226.                                                                                                                                                 if(times[6] > 0x99)
  227.                                                                                                                                                 {
  228.                                                                                                                                                                 times[6] = 0x00;   
  229.                                                                                                                                                 }
  230.                                                                                                                                         WriteCommand(0x80+2);
  231.                                                                                                                                         WriteData(shuzi[times[6]>>4]);
  232.                                                                                                                                         WriteData(shuzi[times[6]&0x0f]);
  233.                                                                                                                                         WriteCommand(0x80+3);
  234.                                                                                                                                         break;
  235.                                                                                                                 case 2:                                 //月
  236.                                                                                                                                                 times[4]++;
  237.                                                                                                                                                 if((times[4]&0x0f) == 0x0a)
  238.                                                                                                                                                 {
  239.                                                                                                                                                                 times[4] += 0x06;      
  240.                                                                                                                                                 }
  241.                                                                                                                                                 if(times[4] > 0x12)
  242.                                                                                                                                                 {
  243.                                                                                                                                                                 times[4] = 0x01;   
  244.                                                                                                                                                 }
  245.                                                                                                                                                 WriteCommand(0x80+5);
  246.                                                                                                                                                 WriteData(shuzi[times[4]>>4]);
  247.                                                                                                                                                 WriteData(shuzi[times[4]&0x0f]);
  248.                                                                                                                                                 WriteCommand(0x80+6);
  249.                                                                                                                                                 break;
  250.                                                                                                                 case 3:                        //
  251.                                                                                                                                                 times[3]++;
  252.                                                                                                                                                 if((times[3]&0x0f) == 0x0a)
  253.                                                                                                                                                 {
  254.                                                                                                                                                                 times[3] += 0x06;      
  255.                                                                                                                                                 }
  256.                                                                                                                                                 if(times[3] > 0x31)
  257.                                                                                                                                                 {
  258.                                                                                                                                                                 times[3] = 0x01;   
  259.                                                                                                                                                 }
  260.                                                                                                                                                 times[5]++;
  261.                                                                                                                                                 if((times[5]&0x0f) == 0x08)
  262.                                                                                                                                                 {
  263.                                                                                                                                                                 times[5] = 0x01;      
  264.                                                                                                                                                 }
  265.                                                                                                                                                 WriteCommand(0x80+8);
  266.                                                                                                                                                 WriteData(shuzi[times[3]>>4]);
  267.                                                                                                                                                 WriteData(shuzi[times[3]&0x0f]);
  268.                                                                                                                                                 WriteCommand(0x80+9);
  269.                                                                                                                                        
  270.                                                                                                                                                 break;
  271.                                                                                                                  case 4:         //?
  272.                                                                                                                                          times[5]++;
  273.                                                                                                                                                 if((times[5]&0x0f) == 0x08)
  274.                                                                                                                                                 {
  275.                                                                                                                                                                 times[5] = 0x01;      
  276.                                                                                                                                                 }
  277.                                                                                                                                                 WriteCommand(0x80+15);
  278.                                                                                                                                                 WriteData(shuzi[times[5]]);
  279.                                                                                                                                                 WriteCommand(0x80+15);
  280.                                                                                                                                        
  281.                                                                                                                                                 break;
  282.                                                                                                                  case 5:         //?
  283.                                                                                                                                                 times[2]++;
  284.                                                                                                                                                 if((times[2]&0x0f) == 0x0a)
  285.                                                                                                                                                 {
  286.                                                                                                                                                                 times[2] += 0x06;      
  287.                                                                                                                                                 }
  288.                                                                                                                                                 if(times[2] > 0x23)
  289.                                                                                                                                                 {
  290.                                                                                                                                                                 times[2] = 0x00;   
  291.                                                                                                                                                 }
  292.                                                                                                                                                 WriteCommand(0x80+0x40+0);
  293.                                                                                                                                                 WriteData(shuzi[times[2]>>4]);
  294.                                                                                                                                                 WriteData(shuzi[times[2]&0x0f]);
  295.                                                                                                                                                 WriteCommand(0x80+0x40+1);
  296.                                                                                                                
  297.                                                                                                                                                 break;
  298.                                                                                                                  case 6:         //?
  299.                                                                                                                                                 times[1]++;
  300.                                                                                                                                                 if((times[1]&0x0f) == 0x0a)
  301.                                                                                                                                                 {
  302.                                                                                                                                                                 times[1] += 0x06;      
  303.                                                                                                                                                 }
  304.                                                                                                                                                 if(times[1] > 0x59)
  305.                                                                                                                                                 {
  306.                                                                                                                                                                 times[1] = 0x00;   
  307.                                                                                                                                                 }
  308.                                                                                                                                                 WriteCommand(0x80+0x40+3);
  309.                                                                                                                                                 WriteData(shuzi[times[1]>>4]);
  310.                                                                                                                                                 WriteData(shuzi[times[1]&0x0f]);
  311.                                                                                                                                                 WriteCommand(0x80+0x40+4);
  312.                                                                                                                                
  313.                                                                                                                                                 break;
  314.                                                                                                                  case 0:         //?
  315.                                                                                                                                                 times[0]++;
  316.                                                                                                                                                 if((times[0]&0x0f) == 0x0a)
  317.                                                                                                                                                 {
  318.                                                                                                                                                                 times[0] += 0x06;      
  319.                                                                                                                                                 }
  320.                                                                                                                                                 if(times[0] > 0x59)
  321.                                                                                                                                                 {
  322.                                                                                                                                                                 times[0] = 0x00;   
  323.                                                                                                                                                 }
  324.                                                                                                                                                 WriteCommand(0x80+0x40+6);
  325.                                                                                                                                                 WriteData(shuzi[times[0]>>4]);
  326.                                                                                                                                                 WriteData(shuzi[times[0]&0x0f]);
  327.                                                                                                                                                 WriteCommand(0x80+0x40+7);
  328.                                                                                                                                        
  329.                                                                                                                                                 break;
  330.                                                                                                                 default:
  331.                                                                                                                                                 break;                           
  332.                                                                                                                                                
  333.                                                                                                                 }
  334.                                                                                                 }
  335.                                                                                                 break;
  336.                                                 case 0x03:
  337.                                                                                                 if(cflag)
  338.                                                                                                 {
  339.                                                                                                                 cflag = 0;
  340.                                                                                                                 PP = 0;
  341.                                                                                                          WriteCommand(0X0C);   //取消 并關光標
  342.                                                                                                 }
  343.                                                                                                 break;
  344.                                                 case 0x04:                                 //保存數據到 DS1302
  345.                                                                                                 if(cflag)
  346.                                                                                                 {
  347.                                                                                                                 cflag = 0;
  348.                                                                                                                 PP = 0;
  349.                                                                                                          WriteCommand(0X0C);   //關光標
  350.                                                                                                         ds1302_write_byte(ds1302_control_add,0x00);                        //關閉寫保護
  351.                                                                                                         ds1302_write_byte(ds1302_sec_add,0x80);                                //暫停
  352.                                                                                                         ds1302_write_byte(ds1302_charger_add,0xa9);                        //涓流充電
  353.                                                                                                        
  354.                                                                                                         ds1302_write_byte(ds1302_year_add,times[6]);                //年
  355.                                                                                                         ds1302_write_byte(ds1302_month_add,times[4]);        //月
  356.                                                                                                         ds1302_write_byte(ds1302_day_add,times[5]);                //周
  357.                                                                                                         ds1302_write_byte(ds1302_date_add,times[3]);                //日
  358.                                                                                                        
  359.                                                                                                         ds1302_write_byte(ds1302_hr_add,times[2]);                //時
  360.                                                                                                         ds1302_write_byte(ds1302_min_add,times[1]);                //分
  361.                                                                                                         ds1302_write_byte(ds1302_sec_add,times[0]);                //秒
  362.                                                                                                         ds1302_write_byte(ds1302_control_add,0x80);                        //打開寫保護
  363.                                                                                                        
  364.                                                                                                          // Set_DS1302(times);   //DS1302 寫入時間
  365.                                                                                                 }
  366.                                                                                                 break;
  367.                                                  case 0x05:            //保存數據到鬧鐘
  368.                                                                                                 if(cflag)
  369.                                                                                                 {
  370.                                                                                                                 cflag = 0;
  371.                                                                                                                 PP = 0;
  372.                                                                                                          WriteCommand(0X0C);   //關光標
  373.                                                                                                         for(i=0;i<7;i++){
  374.                                                                                                                                 clock_buf[i]=times[i];

  375.                                                                                                         }
  376.                                                                                                 //        strcpy(clock_buf,times);
  377.                                                                                                 }
  378.                                                                                                 break;
  379.                                                 default:
  380.                                                                                                 break;                    
  381.                         }
  382. }
  383. void dateTrans(void){
  384.        
  385.         times[6]=time_buf[1];
  386.         times[5]=time_buf[7];
  387.        
  388.         times[4]=time_buf[2];
  389.         times[3]=time_buf[3];
  390.         times[2]=time_buf[4];
  391.         times[1]=time_buf[5];
  392.         times[0]=time_buf[6];

  393. }
  394. void alarm_aclok(void)
  395.         {               
  396.                
  397.                 if((times[2]==clock_buf[2])&&(times[1]==clock_buf[1])&&(times[0]==0))        {/*buzeer= 0;*/        music=1;buzeer_music();/*可替換為普通鬧鐘*/}     //1111 0111 P2 & 0xf7
  398.                 //else        {        buzeer= 1;}
  399. }
  400.        
  401. void T1_time() interrupt 3 {

  402.                 TH1=0xfc;
  403.                 TL1=0x66;
  404.                 counter++;
  405.         if(counter == 10)                { counter = 0; baifenmiao++;}
  406.         if(baifenmiao == 10)                {baifenmiao = 0; shifenmiao++;}
  407.         if(shifenmiao == 10)                {shifenmiao = 0;led1=~led1; miao++;}
  408.         if(miao == 10)                { miao = 0; shimiao++;}
  409.         if(shimiao == 10)                { shimiao = 0; baimiao++;}
  410.         if(baimiao == 10) baimiao =0;
  411.        
  412. }

  413. void timer_run(void)
  414. {
  415.                 if(key==2) keyflg=2;                       //計時功能
  416.                 while(key==2)
  417.                                 {       
  418.                                                 WriteCommand(0x01); //顯示清屏
  419.                                                 while(keyflg==2){
  420.                                                                         key = Key4Scan();
  421.                                                                         if(key==4) keyflg=0;
  422.                                                                         WriteCommand(0x80+5);            //計時功能
  423.                                                                         WriteData(shuzi[baimiao]);
  424.                                                                         WriteData(shuzi[shimiao]);
  425.                                                                         WriteData(shuzi[miao]);
  426.                                                                         WriteData('.');                               
  427.                                                                         WriteData(shuzi[shifenmiao]);
  428.                                                                         WriteData(shuzi[baifenmiao]);
  429.                                                         if(key==2) TR1=~TR1;
  430.                                                         if(key==3) {shifenmiao=0;baifenmiao=0;baimiao=0;shimiao=0;miao=0;TR0=0;}
  431.                                         }
  432.                                         WriteCommand(0x01); //顯示清屏
  433.                                 }
  434. }
  435. void timer_runback(void){
  436.                 if(key==3) keyflg=3;                       //倒計時功能
  437.                 while(key==3)
  438.                         {
  439.                                 WriteCommand(0x01); //顯示清屏
  440.                                 WriteCommand(0x80+5); //顯示清屏   k1 功能選擇 k2 定是數據選擇 k3數據保存
  441.                                                 WriteData('0');
  442.                                                 WriteData('0');
  443.                                                 WriteData('0');
  444.                                         /*        WriteData(':');
  445.                                                 WriteData('0');
  446.                                                 WriteData('0');*/
  447.                                 while(keyflg==3)
  448.                                         {
  449.                                                 key = Key4Scan();
  450.                                                 if(key==4) keyflg=0;
  451.                                        
  452.                                                 switch(key)   //Key4Scan()
  453.                         {
  454.                                                 case 0x01:
  455.                                                                                                 switch(PPP++)      //??????
  456.                                                                                                 {
  457.                                                                                                 case 0:  WriteCommand(0x80+5);break;                                                //分鐘
  458.                                                                                                 case 1:  WriteCommand(0x80+6);break;            //
  459.                                                                                                 case 2:  WriteCommand(0x80+7);break;                                                //
  460.                                                                                         /*case 3:  WriteCommand(0x80+9);break;                                //        秒
  461.                                                                                                 case 4:  WriteCommand(0x80+10);break;                                //*/
  462.                                                                                                 default:break;
  463.                                                                                                 }                  
  464.                                                                                                 WriteCommand(0x0f);//光標閃爍
  465.                                                                                                 if(PPP == 4){ PPP = 0; time[0]=time[1]=time[2] =0; }              //7還是 8好像和編譯器有關系
  466.                                                                                                
  467.                                                                                                 cflg = 1;          //標志位
  468.                                                                                                
  469.                                                                                                 break;
  470.                                                 case 0x02:
  471.                                                                                                 if(cflg)
  472.                                                                                                 {
  473.                                                                                                                 switch(PPP-1)
  474.                                                                                                                 {
  475.                                                                                                                 case 0:          // 百秒                                       
  476.                                                                                                                                                 time[0]++;
  477.                                                                                                                                
  478.                                                                                                                                                 if(time[0] > 9)
  479.                                                                                                                                                 {
  480.                                                                                                                                                                 time[0] = 0;   
  481.                                                                                                                                                 }
  482.                                                                                                                                         WriteCommand(0x80+5);
  483.                                                                                                                                         WriteData(shuzi[time[0]]);
  484.                                                                                                                                         WriteCommand(0x80+5);
  485.                                                                                                                                         break;
  486.                                                                                                                 case 1:                                 //十秒
  487.                                                                                                                                                 time[1]++;
  488.                                                                                                                
  489.                                                                                                                                                 if(time[1] > 9)
  490.                                                                                                                                                 {
  491.                                                                                                                                                                 time[1] = 0;   
  492.                                                                                                                                                 }
  493.                                                                                                                                                 WriteCommand(0x80+6);
  494.                                                                                                                                                 WriteData(shuzi[time[1]]);
  495.                                                                                                                                                 WriteCommand(0x80+6);
  496.                                                                                                                                                 break;
  497.                                                                                                                 case 2:                        //秒
  498.                                                                                                                                                 time[2]++;
  499.                                                                                                                                                 if(time[2] > 9)
  500.                                                                                                                                                 {
  501.                                                                                                                                                                 time[2] = 0;   
  502.                                                                                                                                                 }
  503.                                                                                                                                                 WriteCommand(0x80+7);
  504.                                                                                                                                                 WriteData(shuzi[time[2]]);;
  505.                                                                                                                                                 WriteCommand(0x80+7);
  506.                                                                                                                                        
  507.                                                                                                                                                 break;
  508.                                        
  509.                                                                                                        
  510.                                                                                                                 default:
  511.                                                                                                                                                 break;                           
  512.                                                                                                                                                
  513.                                                                                                                 }
  514.                                                                                                 }
  515.                                                                                                 break;
  516.                                                 case 0x03:
  517.                                                                                                 if(cflg)
  518.                                                                                                 {
  519.                                                                                                                 cflg = 0;
  520.                                                                                                                 PPP = 0;
  521.                                                                                                          WriteCommand(0X0C);   //取消 并關光標
  522.                                                                                                                 miao=9-time[2];
  523.                                                                                                                 shimiao=9-time[1];
  524.                                                                                                                 baimiao=9-time[0];
  525.                                                                                        
  526.                                                                                                 }
  527.                                                                                                 break;
  528.                                  
  529.                                                 /* case 0x05:            //保存數據到鬧鐘
  530.                                                                                                 if(cflag)
  531.                                                                                                 {
  532.                                                                                                                 cflag = 0;
  533.                                                                                                                 PP = 0;
  534.                                                                                                          WriteCommand(0X0C);   //關光標

  535.                                                                                                 }
  536.                                                                                                 break; */
  537.                                                 default:
  538.                                                                                                 break;                    
  539.                         }
  540.                                 while(!cflg)       
  541.                                 {
  542.                                        
  543.                                                 WriteCommand(0X80+5);   //取消 并關光標               
  544.                                                 WriteData(shuzi[9-baimiao]);
  545.                                                 WriteData(shuzi[9-shimiao]);
  546.                                                 WriteData(shuzi[9-miao]);
  547.                                                 key = Key4Scan();
  548.                                                 if(key==4){cflg=1; keyflg=0; }
  549.                                                 while((9-baimiao)==0&&(9-shimiao==0)&&(9-miao)==0)
  550.                                                 {
  551.                                                                 while(keyflg){       
  552.                                                                         led3=~led3;
  553.                                                                         DelayMs(3500);
  554.                                                                         key = Key4Scan();
  555.                                                                         WriteCommand(0X80+7);
  556.                                                                         WriteData('0');
  557.                                                                         if(key==4){cflg=1; keyflg=0; }
  558.                                                                 }
  559.                                                 }

  560.                                 }
  561.                                         }
  562.                         WriteCommand(0X01);       
  563.                         }

  564. }

  565. void clock_display(void)
  566. {
  567.                 if(key==5)
  568.                 {
  569.                         WriteCommand(0x01);
  570.                         WriteCommand(0x80+5);
  571.                         WriteData(shuzi[clock_buf[2]/16]);
  572.                         WriteData(shuzi[clock_buf[2]%16]);
  573.                         WriteData(':');
  574.                         WriteData(shuzi[clock_buf[1]/16]);
  575.                         WriteData(shuzi[clock_buf[1]%16]);       
  576.                         delay_ms(2000);                
  577.                                                
  578.                                        
  579.                
  580.                 }
  581. }
  582. void clock_delay(void)
  583. {
  584.        
  585.                 if(key==6)
  586.                 {
  587.                         miao=0;
  588.                         shimiao=0;
  589.                         TR0=0;
  590.                         buzeer=1;
  591.                 }
  592.         if(keyflg==6)
  593.                         {
  594.                                         if(miao==9)
  595.                                 {
  596.                                                   
  597.                                                                 //buzeer=0;
  598.                                                         TR0=1;
  599.                                                         buzeer_music();
  600.                                 }
  601.                         }       

  602. }

  603. void start(void)
  604. {
  605.                
  606.        
  607.                 WriteCommand(0x80+3);
  608.           
  609.           WriteData('3');
  610.                 WriteData('-');
  611.           WriteData('0');
  612.                 WriteData('5');
  613.                 WriteData('-');
  614.                 WriteData('0');
  615.                 WriteData('6');

  616.        
  617.           led2=1;
  618.                 delay_ms(1000);        
  619. ……………………

  620. …………限于本文篇幅 余下代碼請從51黑下載附件…………
復制代碼

所有資料51hei提供下載:
RTC實時時鐘DS1302液晶顯示.rar (96.15 KB, 下載次數: 24)


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

使用道具 舉報

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

本版積分規則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板: 日本精品一区二区三区在线观看视频 | 日韩精品在线观看免费 | 日一日操一操 | 黄色片免费| 国产一区二区三区在线看 | 精品一区在线 | 国产日韩欧美一区二区在线播放 | 欧洲精品在线观看 | 国产在线网址 | 狠狠干在线 | 4hu最新网址| 久久久国产精品一区 | 国产精品视频不卡 | 亚洲综合久久网 | 青青青伊人 | 精品欧美在线观看 | 天堂一区 | 欧美久久久久久久 | 天堂一区二区三区四区 | 亚洲一区二区在线 | 午夜电影福利 | 亚洲黄色高清视频 | 亚洲精品九九 | 国产精品成人一区二区 | 伊人二区 | 精品一区二区在线观看 | 亚洲欧洲综合av | 日韩一区二区在线看 | www.夜夜骑 | 日韩一区二区三区精品 | 亚洲网站在线观看 | 91精品久久久久 | 免费观看色 | 国产线视频精品免费观看视频 | 国产男女视频网站 | 中文字幕 国产 | 欧美精品免费观看二区 | 黑人粗黑大躁护士 | 午夜影院 | 国产网站在线免费观看 | 国产精品国产三级国产播12软件 |