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

 找回密碼
 立即注冊

QQ登錄

只需一步，快速開始

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

基于51單片機的多功能電子時鐘設計

[復制鏈接]
跳轉到指定樓層
樓主
ID:890502 發表于 2021-8-10 21:27 | 只看該作者 回帖獎勵 |倒序瀏覽 |閱讀模式
  1. #include <reg52.h>
  2. #include <intrins.h>

  4. #define uchar unsigned char        // 以后unsigned char就可以用uchar代替
  5. #define uint  unsigned int        // 以后unsigned int 就可以用uint 代替

  7. sfr ISP_DATA  = 0xe2;                // 數據寄存器
  8. sfr ISP_ADDRH = 0xe3;                // 地址寄存器高八位
  9. sfr ISP_ADDRL = 0xe4;                // 地址寄存器低八位
  10. sfr ISP_CMD   = 0xe5;                // 命令寄存器
  11. sfr ISP_TRIG  = 0xe6;                // 命令觸發寄存器
  12. sfr ISP_CONTR = 0xe7;                // 命令寄存器

  14. sbit LcdRs_P    = P2^7;               // 1602液晶的RS管腳      
  15. sbit LcdRw_P   = P2^6;               // 1602液晶的RW管腳
  16. sbit LcdEn_P   = P2^5;               // 1602液晶的EN管腳
  17. sbit RST_P     = P1^3;                        // 時鐘芯片DS1302的RST管腳
  18. sbit SDA_P     = P1^2;                        // 時鐘芯片DS1302的SDA管腳
  19. sbit SCK_P     = P1^1;                        // 時鐘芯片DS1302的SCK管腳
  20. sbit KeySet_P   = P3^2;                        // 設置時間按鍵
  21. sbit KeyClock_P = P3^3;                        // 設置鬧鐘按鍵
  22. sbit KeyDown_P  = P3^4;                // 減按鍵
  23. sbit KeyUp_P    = P3^5;                // 加按鍵
  24. sbit Buzzer_P   = P2^0;                        // 蜂鳴器
  25. sbit DQ         = P1^0;                // DS18B20傳感器的引腳定義

  27. uchar TimeBuff[7]={17,9,1,6,18,30,40};          // 時間數組，默認2017年9月1日，星期五，18:30:40
  28. // TimeBuff[0] 代表年份，范圍00-99
  29. // TimeBuff[1] 代表月份，范圍1-12
  30. // TimeBuff[2] 代表日期，范圍1-31
  31. // TimeBuff[3] 代表星期，范圍1-7，1是星期天，2是星期一... ...
  32. // TimeBuff[4] 代表小時，范圍00-23
  33. // TimeBuff[5] 代表分鐘，范圍00-59
  34. // TimeBuff[6] 代表秒鐘，范圍00-59

  36. uchar Clock_Hour;                                        // 鬧鐘的小時
  37. uchar Clock_Minute;                                // 鬧鐘的分鐘
  38. uchar Clock_Swt;                                        // 鬧鐘的開關
  39. uchar Buzzer_Flag=0;                                // 蜂鳴器工作標志


  42. /*********************************************************/
  43. // 單片機內部EEPROM不使能
  44. /*********************************************************/
  45. void ISP_Disable()
  46. {
  47.         ISP_CONTR = 0;
  48.         ISP_ADDRH = 0;
  49.         ISP_ADDRL = 0;
  50. }

  52. /*********************************************************/
  53. // 從單片機內部EEPROM讀一個字節，從0x2000地址開始
  54. /*********************************************************/
  55. unsigned char EEPROM_Read(unsigned int add)
  56. {
  57.         ISP_DATA  = 0x00;
  58.         ISP_CONTR = 0x83;
  59.         ISP_CMD   = 0x01;
  60.         ISP_ADDRH = (unsigned char)(add>>8);
  61.         ISP_ADDRL = (unsigned char)(add&0xff);
  62.         // 對STC89C51系列來說，每次要寫入0x46，再寫入0xB9,ISP/IAP才會生效
  63.         ISP_TRIG  = 0x46;          
  64.         ISP_TRIG  = 0xB9;
  65.         _nop_();
  66.         ISP_Disable();
  67.         return (ISP_DATA);
  68. }

  70. /*********************************************************/
  71. // 往單片機內部EEPROM寫一個字節，從0x2000地址開始
  72. /*********************************************************/
  73. void EEPROM_Write(unsigned int add,unsigned char ch)
  74. {
  75.         ISP_CONTR = 0x83;
  76.         ISP_CMD   = 0x02;
  77.         ISP_ADDRH = (unsigned char)(add>>8);
  78.         ISP_ADDRL = (unsigned char)(add&0xff);
  79.         ISP_DATA  = ch;
  80.         ISP_TRIG  = 0x46;
  81.         ISP_TRIG  = 0xB9;
  82.         _nop_();
  83.         ISP_Disable();
  84. }

  86. /*********************************************************/
  87. // 擦除單片機內部EEPROM的一個扇區
  88. // 寫8個扇區中隨便一個的地址，便擦除該扇區，寫入前要先擦除
  89. /*********************************************************/
  90. void Sector_Erase(unsigned int add)          
  91. {
  92.         ISP_CONTR = 0x83;
  93.         ISP_CMD   = 0x03;
  94.         ISP_ADDRH = (unsigned char)(add>>8);
  95.         ISP_ADDRL = (unsigned char)(add&0xff);
  96.         ISP_TRIG  = 0x46;
  97.         ISP_TRIG  = 0xB9;
  98.         _nop_();
  99.         ISP_Disable();
  100. }

  102. /*********************************************************/
  103. // 毫秒級的延時函數，time是要延時的毫秒數
  104. /*********************************************************/
  105. void DelayMs(uint time)
  106. {
  107.         uint i,j;
  108.         for(i=0;i<time;i++)
  109.                 for(j=0;j<112;j++);
  110. }

  112. /*********************************************************/
  113. // 延時15微秒
  114. /*********************************************************/
  115. void Delay15us(void)
  116. {
  117.         _nop_();
  118.         _nop_();
  119.         _nop_();
  120.         _nop_();
  121.         _nop_();
  122.         _nop_();
  123.         _nop_();
  124.         _nop_();
  125.         _nop_();
  126.         _nop_();
  127.         _nop_();
  128.         _nop_();
  129.         _nop_();
  130.         _nop_();
  131.         _nop_();
  132. }

  134. /*********************************************************/
  135. // 復位DS18B20（初始化）
  136. /*********************************************************/
  137. void DS18B20_ReSet(void)
  138. {
  139.         uchar i;
  140.         DQ=0;
  141.         i=240;
  142.         while(--i);
  143.         DQ=1;
  144.         i=30;
  145.         while(--i);
  146.         while(~DQ);
  147.         i=4;
  148.         while(--i);
  149. }

  151. /*********************************************************/
  152. // 向DS18B20寫入一個字節
  153. /*********************************************************/
  154. void DS18B20_WriteByte(uchar dat)
  155. {
  156.         uchar j;
  157.         uchar btmp;
  158.        
  159.         for(j=0;j<8;j++)
  160.         {
  161.                 btmp=0x01;
  162.                 btmp=btmp<<j;
  163.                 btmp=btmp&dat;
  164.                 if(btmp>0)                // 寫1
  165.                 {
  166.                         DQ=0;
  167.                         Delay15us();
  168.                         DQ=1;
  169.                         Delay15us();
  170.                         Delay15us();
  171.                         Delay15us();
  172.                         Delay15us();
  173.                 }
  174.                 else                        // 寫0
  175.                 {
  176.                         DQ=0;
  177.                         Delay15us();
  178.                         Delay15us();
  179.                         Delay15us();
  180.                         Delay15us();
  181.                         DQ=1;
  182.                         Delay15us();
  183.                 }
  184.         }
  185. }

  187. /*********************************************************/
  188. // 讀取溫度值
  189. /*********************************************************/
  190. int DS18B20_ReadTemp(void)
  191. {
  192.         uchar j;
  193.         int b,temp=0;       

  195.         DS18B20_ReSet();                                        // 產生復位脈
  196.         DS18B20_WriteByte(0xcc);                        // 忽略ROM指令
  197.         DS18B20_WriteByte(0x44);                        // 啟動溫度轉換指令

  199.         DS18B20_ReSet();                                        // 產生復位脈
  200.         DS18B20_WriteByte(0xcc);                        // 忽略ROM指令
  201.         DS18B20_WriteByte(0xbe);                        // 讀取溫度指令

  203.         for(j=0;j<16;j++)                                        // 讀取溫度數量
  204.         {                                               
  205.                 DQ=0;
  206.                 _nop_();
  207.                 _nop_();
  208.                 DQ=1;       
  209.                 Delay15us();
  210.                 b=DQ;
  211.                 Delay15us();
  212.                 Delay15us();
  213.                 Delay15us();
  214.                 b=b<<j;
  215.                 temp=temp|b;
  216.         }
  217.        
  218.         temp=temp*0.0625*10;                                // 合成溫度值并放大10倍                                       
  219.         return (temp);                                                // 返回檢測到的溫度值
  220. }

  222. /*********************************************************/
  223. // 1602液晶寫命令函數，cmd就是要寫入的命令
  224. /*********************************************************/
  225. void LcdWriteCmd(uchar cmd)
  226. {
  227.         LcdRs_P = 0;
  228.         LcdRw_P = 0;
  229.         LcdEn_P = 0;
  230.         P0=cmd;
  231.         DelayMs(2);
  232.         LcdEn_P = 1;   
  233.         DelayMs(2);
  234.         LcdEn_P = 0;       
  235. }

  237. /*********************************************************/
  238. // 1602液晶寫數據函數，dat就是要寫入的數據
  239. /*********************************************************/
  240. void LcdWriteData(uchar dat)
  241. {
  242.         LcdRs_P = 1;
  243.         LcdRw_P = 0;
  244.         LcdEn_P = 0;
  245.         P0=dat;
  246.         DelayMs(2);
  247.         LcdEn_P = 1;   
  248.         DelayMs(2);
  249.         LcdEn_P = 0;
  250. }

  252. /*********************************************************/
  253. // 1602液晶初始化函數
  254. /*********************************************************/
  255. void LcdInit()
  256. {
  257.         LcdWriteCmd(0x38);        // 16*2顯示，5*7點陣，8位數據口
  258.         LcdWriteCmd(0x0C);        // 開顯示，不顯示光標
  259.         LcdWriteCmd(0x06);        // 地址加1，當寫入數據后光標右移
  260.         LcdWriteCmd(0x01);        // 清屏
  261. }

  263. /*********************************************************/
  264. // 液晶光標定位函數
  265. /*********************************************************/
  266. void LcdGotoXY(uchar line,uchar column)
  267. {
  268.         // 第一行
  269.         if(line==0)        
  270.                 LcdWriteCmd(0x80+column);
  271.         // 第二行
  272.         if(line==1)        
  273.                 LcdWriteCmd(0x80+0x40+column);
  274. }

  276. /*********************************************************/
  277. // 液晶輸出字符串函數
  278. /*********************************************************/
  279. void LcdPrintStr(uchar *str)
  280. {
  281.         while(*str!='\0')
  282.                         LcdWriteData(*str++);
  283. }

  285. /*********************************************************/
  286. // 液晶顯示內容的初始化
  287. /*********************************************************/
  288. void LcdShowInit()
  289. {
  290.         LcdGotoXY(0,0);
  291.         LcdPrintStr("20  -  -        ");
  292.         LcdGotoXY(1,0);
  293.         LcdPrintStr("  :  :         C");
  294.         LcdGotoXY(1,14);                                // 溫度單位攝氏度上面的圓圈符號
  295.         LcdWriteData(0xdf);       
  296. }

  298. /*********************************************************/
  299. // 液晶輸出數字
  300. /*********************************************************/
  301. void LcdPrintNum(uchar num)
  302. {
  303.         LcdWriteData(num/10+48);                // 十位
  304.         LcdWriteData(num%10+48);                 // 個位
  305. }

  307. /*********************************************************/
  308. // 液晶顯示星期
  309. /*********************************************************/
  310. void LcdPrintWeek(uchar week)
  311. {
  312.         switch(week)
  313.         {
  314.                 case 1: LcdPrintStr(" Sun");        break;
  315.                 case 2: LcdPrintStr(" Mon");        break;
  316.                 case 3: LcdPrintStr("Tues");        break;
  317.                 case 4: LcdPrintStr(" Wed");        break;
  318.                 case 5: LcdPrintStr("Thur");        break;
  319.                 case 6: LcdPrintStr(" Fri");        break;
  320.                 case 7: LcdPrintStr(" Sat");        break;
  321.                 default:                                        break;
  322.         }
  323. }

  325. /*********************************************************/
  326. // 刷新時間顯示
  327. /*********************************************************/
  328. void FlashTime()
  329. {
  330.         LcdGotoXY(0,2);                                                // 年份
  331.         LcdPrintNum(TimeBuff[0]);
  332.         LcdGotoXY(0,5);                                                // 月份
  333.         LcdPrintNum(TimeBuff[1]);
  334.         LcdGotoXY(0,8);                                                // 日期
  335.         LcdPrintNum(TimeBuff[2]);
  336.         LcdGotoXY(1,0);                                                // 小時
  337.         LcdPrintNum(TimeBuff[4]);
  338.         LcdGotoXY(1,3);                                                // 分鐘
  339.         LcdPrintNum(TimeBuff[5]);
  340.         LcdGotoXY(1,6);                                                // 秒鐘
  341.         LcdPrintNum(TimeBuff[6]);
  342.         LcdGotoXY(0,12);                                                // 星期       
  343.         LcdPrintWeek(TimeBuff[3]);

  345. }

  347. /*********************************************************/
  348. // 溫度值的顯示
  349. /*********************************************************/
  350. void LcdPrintTemp(int temp)
  351. {
  352.         if(temp<0)                                                                                                       
  353.         {
  354.                 LcdWriteData('-');                                        // 顯示負號       
  355.                 temp=0-temp;                                                // 負數轉為正數       
  356.         }
  357.         else if(temp>999)                                                 // 顯示百位
  358.         {
  359.                 LcdWriteData(temp/1000+0x30);
  360.         }
  361.         else
  362.         {
  363.                 LcdWriteData(' ');
  364.         }
  365.         LcdWriteData(temp%1000/100+0x30);                // 顯示十位
  366.         LcdWriteData(temp%100/10+0x30);                // 顯示個位
  367.         LcdWriteData('.');                                                // 顯示小數點
  368.         LcdWriteData(temp%10+0x30);                        // 顯示小數后一位小數
  369. }

  371. /*********************************************************/
  372. // 初始化DS1302
  373. /*********************************************************/
  374. void DS1302_Init(void)
  375. {
  376.         RST_P=0;                        // RST腳置低
  377.         SCK_P=0;                        // SCK腳置低
  378.         SDA_P=0;                        // SDA腳置低                               
  379. }

  381. /*********************************************************/
  382. // 從DS1302讀出一字節數據
  383. /*********************************************************/
  384. uchar DS1302_Read_Byte(uchar addr)
  385. {
  386.         uchar i;
  387.         uchar temp;
  388.         RST_P=1;                                                               
  389.         /* 寫入目標地址：addr*/
  390.         for(i=0;i<8;i++)
  391.         {     
  392.                 if(addr&0x01)
  393.                         SDA_P=1;
  394.                 else
  395.                         SDA_P=0;
  396.                 SCK_P=1;
  397.                 _nop_();
  398.                 SCK_P=0;
  399.                 _nop_();
  400.                 addr=addr>> 1;
  401.         }
  402.         /* 讀出該地址的數據 */
  403.         for(i=0;i<8;i++)
  404.         {
  405.                 temp=temp>>1;
  406.                 if(SDA_P)
  407.                         temp|= 0x80;
  408.                 else
  409.                         temp&=0x7F;
  410.                 SCK_P=1;
  411.                 _nop_();
  412.                 SCK_P=0;
  413.                 _nop_();
  414.         }
  415.         RST_P=0;
  416.         return temp;
  417. }

  419. /*********************************************************/
  420. // 向DS1302寫入一字節數據
  421. /*********************************************************/
  422. void DS1302_Write_Byte(uchar addr, uchar dat)
  423. {
  424.         uchar i;
  425.         RST_P = 1;
  426.         /* 寫入目標地址：addr*/
  427.         for(i=0;i<8;i++)
  428.         {
  429.                 if(addr&0x01)
  430.                         SDA_P=1;
  431.                 else
  432.                         SDA_P=0;
  433.                 SCK_P=1;
  434.                 _nop_();
  435.                 SCK_P=0;
  436.                 _nop_();
  437.                 addr=addr>>1;
  438.         }
  439.         /* 寫入數據：dat*/
  440.         for(i=0;i<8;i++)
  441.         {
  442.                 if(dat&0x01)
  443.                         SDA_P=1;
  444.                 else
  445.                         SDA_P=0;
  446.                 SCK_P=1;
  447.                 _nop_();
  448.                 SCK_P=0;
  449.                 _nop_();
  450.                 dat=dat>>1;
  451.         }
  452.         RST_P=0;                                       
  453. }

  455. /*********************************************************/
  456. // 向DS1302寫入時間數據
  457. /*********************************************************/
  458. void DS1302_Write_Time()
  459. {
  460.           uchar i;
  461.         uchar temp1;
  462.         uchar temp2;

  464.         for(i=0;i<7;i++)                        // 十進制轉BCD碼
  465.         {
  466.                 temp1=(TimeBuff[i]/10)<<4;
  467.                 temp2=TimeBuff[i]%10;
  468.                 TimeBuff[i]=temp1+temp2;
  469.         }
  470.        
  471.         DS1302_Write_Byte(0x8E,0x00);                                        // 關閉寫保護
  472.         DS1302_Write_Byte(0x80,0x80);                                        // 暫停時鐘
  473.         DS1302_Write_Byte(0x8C,TimeBuff[0]);                        // 年
  474.         DS1302_Write_Byte(0x88,TimeBuff[1]);                                // 月
  475.         DS1302_Write_Byte(0x86,TimeBuff[2]);                                // 日
  476.         DS1302_Write_Byte(0x8A,TimeBuff[3]);                        // 星期
  477.         DS1302_Write_Byte(0x84,TimeBuff[4]);                                // 時
  478.         DS1302_Write_Byte(0x82,TimeBuff[5]);                                // 分
  479.         DS1302_Write_Byte(0x80,TimeBuff[6]);                                // 秒
  480.         DS1302_Write_Byte(0x80,TimeBuff[6]&0x7F);                // 運行時鐘
  481.         DS1302_Write_Byte(0x8E,0x80);                                        // 打開寫保護  
  482. }

  484. /*********************************************************/
  485. // 從DS1302讀出時間數據
  486. /*********************************************************/
  487. void DS1302_Read_Time()  
  488. {
  489.         uchar i;

  491.         TimeBuff[0]=DS1302_Read_Byte(0x8D);                        // 年
  492.         TimeBuff[1]=DS1302_Read_Byte(0x89);                        // 月
  493.         TimeBuff[2]=DS1302_Read_Byte(0x87);                        // 日
  494.         TimeBuff[3]=DS1302_Read_Byte(0x8B);                        // 星期
  495.         TimeBuff[4]=DS1302_Read_Byte(0x85);                        // 時
  496.         TimeBuff[5]=DS1302_Read_Byte(0x83);                        // 分
  497.         TimeBuff[6]=(DS1302_Read_Byte(0x81))&0x7F;                // 秒

  499.         for(i=0;i<7;i++)                // BCD轉十進制
  500.         {           
  501.                 TimeBuff[i]=(TimeBuff[i]/16)*10+TimeBuff[i]%16;
  502.         }
  503. }
  504. }

  506. /*********************************************************/
  507. // 按鍵掃描(設置時間)
  508. /*********************************************************/
  509. void KeyScanf1()
  510. {
  511.         if(KeySet_P==0)
  512.         {
  513.                 LcdWriteCmd(0x0f);                        // 啟動光標閃爍
  514.                 LcdGotoXY(0,3);                                // 定位光標到年份閃爍
  515.                 DelayMs(10);                                        // 延時等待，消除按鍵按下的抖動
  516.                 while(!KeySet_P);                                // 等待按鍵釋放
  517.                 DelayMs(10);                                        // 延時等待，消除按鍵松開的抖動
  518.                
  519.                 /* 調整年份 */
  520.                 while(1)
  521.                 {
  522.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  523.                         {
  524.                                 if(TimeBuff[0]>0)                                // 判斷年份是否大于0               
  525.                                         TimeBuff[0]--;                                // 是的話就減去1
  526.                                 LcdGotoXY(0,2);                                // 光標定位到年份的位置
  527.                                 LcdPrintNum(TimeBuff[0]);                // 刷新顯示改變后的年份
  528.                                 LcdGotoXY(0,3);                                // 定位光標到年份閃爍
  529.                                 DelayMs(300);                                        // 延時0.3秒左右
  530.                         }
  531.                        
  532.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  533.                         {
  534.                                 if(TimeBuff[0]<99)                                // 判斷年份是否小于99
  535.                                         TimeBuff[0]++;                        // 是的話就加上1
  536.                                 LcdGotoXY(0,2);                                // 光標定位到年份的位置
  537.                                 LcdPrintNum(TimeBuff[0]);                // 刷新顯示改變后的年份
  538.                                 LcdGotoXY(0,3);                                // 定位光標到年份閃爍
  539.                                 DelayMs(300);                                        // 延時0.3秒左右
  540.                         }
  541.                        
  542.                         if(KeySet_P==0)
  543.                         {
  544.                                 break;
  545.                         }
  546.                 }
  547.                
  548.                 LcdGotoXY(0,6);                                        // 定位光標到月份閃爍
  549.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  550.                 while(!KeySet_P);                                        // 等待按鍵釋放
  551.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  552.                        
  553.                 /* 調整月份 */
  554.                 while(1)
  555.                 {
  556.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  557.                         {
  558.                                 if(TimeBuff[1]>1)                                // 判斷月份是否大于1               
  559.                                         TimeBuff[1]--;                                // 是的話就減去1
  560.                                 LcdGotoXY(0,5);                                // 光標定位到月份的位置
  561.                                 LcdPrintNum(TimeBuff[1]);                // 刷新顯示改變后的月份
  562.                                 LcdGotoXY(0,6);                                // 定位光標到月份閃爍
  563.                                 DelayMs(300);                                        // 延時0.3秒左右
  564.                         }
  565.                        
  566.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  567.                         {
  568.                                 if(TimeBuff[1]<12)                                // 判斷月份是否小于12
  569.                                         TimeBuff[1]++;                        // 是的話就加上1
  570.                                 LcdGotoXY(0,5);                                // 光標定位到月份的位置
  571.                                 LcdPrintNum(TimeBuff[1]);                // 刷新顯示改變后的月份
  572.                                 LcdGotoXY(0,6);                                // 定位光標到月份閃爍
  573.                                 DelayMs(300);                                        // 延時0.3秒左右
  574.                         }
  575.                        
  576.                         if(KeySet_P==0)
  577.                         {
  578.                                 break;
  579.                         }
  580.                 }
  581.                
  582.                 LcdGotoXY(0,9);                                        // 定位光標到日期閃爍
  583.                 DelayMs(10);                                                // 延時等待，消除按鍵按下的抖動
  584.                 while(!KeySet_P);                                        // 等待按鍵釋放
  585.                 DelayMs(10);                                                // 延時等待，消除按鍵松開的抖動
  586.                
  587.                 /* 調整日期 */
  588.                 while(1)
  589.                 {
  590.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  591.                         {
  592.                                 if(TimeBuff[2]>1)                                // 判斷日期是否大于1               
  593.                                         TimeBuff[2]--;                                // 是的話就減去1
  594.                                 LcdGotoXY(0,8);                                // 光標定位到日期的位置
  595.                                 LcdPrintNum(TimeBuff[2]);                // 刷新顯示改變后的日期
  596.                                 LcdGotoXY(0,9);                                // 定位光標到日期閃爍
  597.                                 DelayMs(300);                                        // 延時0.3秒左右
  598.                         }
  599.                        
  600.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  601.                         {
  602.                                 if(TimeBuff[2]<31)                                // 判斷日期是否小于31
  603.                                         TimeBuff[2]++;                        // 是的話就加上1
  604.                                 LcdGotoXY(0,8);                                // 光標定位到日期的位置
  605.                                 LcdPrintNum(TimeBuff[2]);                // 刷新顯示改變后的日期
  606.                                 LcdGotoXY(0,9);                                // 定位光標到日期閃爍
  607.                                 DelayMs(300);                                        // 延時0.3秒左右
  608.                         }
  609.                        
  610.                         if(KeySet_P==0)
  611.                         {
  612.                                 break;
  613.                         }
  614.                 }
  615.                
  616.                 LcdGotoXY(0,15);                                // 定位光標到星期閃爍
  617.                 DelayMs(10);                                        // 延時等待，消除按鍵按下的抖動
  618.                 while(!KeySet_P);                                // 等待按鍵釋放
  619.                 DelayMs(10);                                        // 延時等待，消除按鍵松開的抖動
  620.                
  621.                 /* 調整星期 */
  622.                 while(1)
  623.                 {
  624.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  625.                         {
  626.                                 if(TimeBuff[3]>1)                                // 判斷星期是否大于1               
  627.                                         TimeBuff[3]--;                                // 是的話就減去1
  628.                                 LcdGotoXY(0,12);                                // 光標定位到星期的位置
  629.                                 LcdPrintWeek(TimeBuff[3]);                // 刷新顯示改變后的星期
  630.                                 LcdGotoXY(0,15);                                // 定位光標到星期閃爍
  631.                                 DelayMs(300);                                        // 延時0.3秒左右
  632.                         }
  633.                        
  634.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  635.                         {
  636.                                 if(TimeBuff[3]<7)                                // 判斷星期是否小于7
  637.                                         TimeBuff[3]++;                        // 是的話就加上1
  638.                                 LcdGotoXY(0,12);                                // 光標定位到星期的位置
  639.                                 LcdPrintWeek(TimeBuff[3]);                // 刷新顯示改變后的星期
  640.                                 LcdGotoXY(0,15);                                // 定位光標到星期閃爍
  641.                                 DelayMs(300);                                        // 延時0.3秒左右
  642.                         }
  643.                        
  644.                         if(KeySet_P==0)
  645.                         {
  646.                                 break;
  647.                         }
  648.                 }

  650.                 LcdGotoXY(1,1);                                // 定位光標到小時閃爍
  651.                 DelayMs(10);                                        // 延時等待，消除按鍵按下的抖動
  652.                 while(!KeySet_P);                                // 等待按鍵釋放
  653.                 DelayMs(10);                                        // 延時等待，消除按鍵松開的抖動
  654.                
  655.                 /* 調整小時 */
  656.                 while(1)
  657.                 {
  658.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  659.                         {
  660.                                 if(TimeBuff[4]>0)                                // 判斷小時是否大于0
  661.                                         TimeBuff[4]--;                                // 是的話就減去1
  662.                                 LcdGotoXY(1,0);                                // 光標定位到小時的位置
  663.                                 LcdPrintNum(TimeBuff[4]);                // 刷新顯示改變后的小時
  664.                                 LcdGotoXY(1,1);                                // 定位光標到小時閃爍
  665.                                 DelayMs(300);                                        // 延時0.3秒左右
  666.                         }
  667.                        
  668.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  669.                         {
  670.                                 if(TimeBuff[4]<23)                                // 判斷小時是否小于23
  671.                                         TimeBuff[4]++;                        // 是的話就加上1
  672.                                 LcdGotoXY(1,0);                                // 光標定位到小時的位置
  673.                                 LcdPrintNum(TimeBuff[4]);                // 刷新顯示改變后的小時
  674.                                 LcdGotoXY(1,1);                                // 定位光標到小時閃爍
  675.                                 DelayMs(300);                                        // 延時0.3秒左右
  676.                         }
  677.                        
  678.                         if(KeySet_P==0)
  679.                         {
  680.                                 break;
  681.                         }
  682.                 }
  683.                
  684.                 LcdGotoXY(1,4);                                // 定位光標到分鐘閃爍
  685.                 DelayMs(10);                                        // 延時等待，消除按鍵按下的抖動
  686.                 while(!KeySet_P);                                // 等待按鍵釋放
  687.                 DelayMs(10);                                        // 延時等待，消除按鍵松開的抖動
  688.                
  689.                 /* 調整分鐘 */
  690.                 while(1)
  691.                 {
  692.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  693.                         {
  694.                                 if(TimeBuff[5]>0)                                // 判斷分鐘是否大于0
  695.                                         TimeBuff[5]--;                                // 是的話就減去1
  696.                                 LcdGotoXY(1,3);                                // 光標定位到分鐘的位置
  697.                                 LcdPrintNum(TimeBuff[5]);                // 刷新顯示改變后的分鐘
  698.                                 LcdGotoXY(1,4);                                // 定位光標到分鐘閃爍
  699.                                 DelayMs(300);                                        // 延時0.3秒左右
  700.                         }
  701.                        
  702.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  703.                         {
  704.                                 if(TimeBuff[5]<59)                                // 判斷分鐘是否小于59
  705.                                         TimeBuff[5]++;                        // 是的話就加上1
  706.                                 LcdGotoXY(1,3);                                // 光標定位到分鐘的位置
  707.                                 LcdPrintNum(TimeBuff[5]);                // 刷新顯示改變后的分鐘
  708.                                 LcdGotoXY(1,4);                                // 定位光標到分鐘閃爍
  709.                                 DelayMs(300);                                        // 延時0.3秒左右
  710.                         }
  711.                        
  712.                         if(KeySet_P==0)
  713.                         {
  714.                                 break;
  715.                         }
  716.                 }
  717.                
  718.                 LcdGotoXY(1,7);                                // 定位光標到秒鐘閃爍
  719.                 DelayMs(10);                                        // 延時等待，消除按鍵按下的抖動
  720.                 while(!KeySet_P);                                // 等待按鍵釋放
  721.                 DelayMs(10);                                        // 延時等待，消除按鍵松開的抖動
  722.                
  723.                 /* 調整秒鐘 */
  724.                 while(1)
  725.                 {
  726.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  727.                         {
  728.                                 if(TimeBuff[6]>0)                                // 判斷秒鐘是否大于0
  729.                                         TimeBuff[6]--;                                // 是的話就減去1
  730.                                 LcdGotoXY(1,6);                                // 光標定位到秒鐘的位置
  731.                                 LcdPrintNum(TimeBuff[6]);                // 刷新顯示改變后的秒鐘
  732.                                 LcdGotoXY(1,7);                                // 定位光標到秒鐘閃爍
  733.                                 DelayMs(300);                                        // 延時0.3秒左右
  734.                         }
  735.                        
  736.                         if(KeyUp_P==0)                                                // 如果加按鍵被下去
  737.                         {
  738.                                 if(TimeBuff[6]<59)                                        // 判斷秒鐘是否小于59
  739.                                         TimeBuff[6]++;                                // 是的話就加上1
  740.                                 LcdGotoXY(1,6);                                        // 光標定位到秒鐘的位置
  741.                                 LcdPrintNum(TimeBuff[6]);                        // 刷新顯示改變后的秒鐘
  742.                                 LcdGotoXY(1,7);                                        // 定位光標到秒鐘閃爍
  743.                                 DelayMs(300);                                                // 延時0.3秒左右
  744.                         }
  745.                        
  746.                         if(KeySet_P==0)
  747.                         {
  748.                                 break;
  749.                         }
  750.                 }
  751.                
  752.                 /* 退出前的設置 */
  753.                 LcdWriteCmd(0x0C);                        // 關閉光標閃爍
  754.                 DS1302_Write_Time();                        // 把新設置的時間值存入DS1302芯片
  755.                 DelayMs(10);                                        // 延時等待，消除按鍵按下的抖動
  756.                 while(!KeySet_P);                                // 等待按鍵釋放
  757.                 DelayMs(10);                                        // 延時等待，消除按鍵松開的抖動
  758.         }
  759. }

  761. /*********************************************************/
  762. // 按鍵掃描(設置鬧鐘)
  763. /*********************************************************/
  764. void KeyScanf2()
  765. {
  766.         if(KeyClock_P==0)
  767.         {
  768.                 LcdGotoXY(0,0);                                                // 液晶顯示為鬧鐘設置的界面
  769.                 LcdPrintStr("Alarm Clock Set ");
  770.                 LcdGotoXY(1,0);                               
  771.                 LcdPrintStr("     :          ");
  772.                 LcdGotoXY(1,3);                                                // 顯示鬧鐘的小時
  773.                 LcdPrintNum(Clock_Hour);
  774.                 LcdGotoXY(1,6);                                                // 顯示鬧鐘的分鐘
  775.                 LcdPrintNum(Clock_Minute);
  776.                 LcdGotoXY(1,10);                                                // 顯示鬧鐘狀態
  777.                 if(Clock_Swt==0)
  778.                 {
  779.                         LcdPrintStr("OFF");
  780.                 }
  781.                 else
  782.                 {
  783.                         LcdPrintStr(" ON");
  784.                 }
  785.                 LcdGotoXY(1,4);                                                // 光標定位
  786.                 LcdWriteCmd(0x0f);                                        // 光標閃爍
  787.                 DelayMs(10);                                                        // 延時等待，消除按鍵按下的抖動
  788.                 while(!KeyClock_P);                                        // 等待按鍵釋放
  789.                 DelayMs(10);                                                        // 延時等待，消除按鍵松開的抖動
  790.                
  791.                 /* 調整鬧鐘小時 */
  792.                 while(1)
  793.                 {
  794.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  795.                         {
  796.                                 if(Clock_Hour>0)                                // 判斷鬧鐘小時是否大于0
  797.                                         Clock_Hour--;                                // 是的話就減去1
  798.                                 LcdGotoXY(1,3);                                // 光標定位到鬧鐘小時的位置
  799.                                 LcdPrintNum(Clock_Hour);                // 刷新顯示改變后的鬧鐘小時
  800.                                 LcdGotoXY(1,4);                                // 定位光標到鬧鐘小時閃爍
  801.                                 DelayMs(300);                                        // 延時0.3秒左右
  802.                         }
  803.                        
  804.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  805.                         {
  806.                                 if(Clock_Hour<23)                                // 判斷鬧鐘小時是否小于23
  807.                                         Clock_Hour++;                                // 是的話就加上1
  808.                                 LcdGotoXY(1,3);                                // 光標定位到鬧鐘小時的位置
  809.                                 LcdPrintNum(Clock_Hour);                // 刷新顯示改變后的鬧鐘小時
  810.                                 LcdGotoXY(1,4);                                // 定位光標到鬧鐘小時閃爍
  811.                                 DelayMs(300);                                        // 延時0.3秒左右
  812.                         }
  813.                        
  814.                         if(KeyClock_P==0)
  815.                         {
  816.                                 break;
  817.                         }
  818.                 }
  819.                
  820.                 LcdGotoXY(1,7);                                                // 定位光標到鬧鐘分鐘的閃爍
  821.                 DelayMs(10);                                                        // 延時等待，消除按鍵按下的抖動
  822.                 while(!KeyClock_P);                                        // 等待按鍵釋放
  823.                 DelayMs(10);                                                        // 延時等待，消除按鍵松開的抖動
  824.                
  825.                 /* 調整分鐘 */
  826.                 while(1)
  827.                 {
  828.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  829.                         {
  830.                                 if(Clock_Minute>0)                                // 判斷鬧鐘分鐘是否大于0
  831.                                         Clock_Minute--;                        // 是的話就減去1
  832.                                 LcdGotoXY(1,6);                                // 光標定位到鬧鐘分鐘的位置
  833.                                 LcdPrintNum(Clock_Minute);                // 刷新顯示改變后的鬧鐘分鐘
  834.                                 LcdGotoXY(1,7);                                // 定位光標到鬧鐘分鐘閃爍
  835.                                 DelayMs(300);                                        // 延時0.3秒左右
  836.                         }
  837.                        
  838.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  839.                         {
  840.                                 if(Clock_Minute<59)                        // 判斷鬧鐘分鐘是否小于59
  841.                                         Clock_Minute++;                        // 是的話就加上1
  842.                                 LcdGotoXY(1,6);                                // 光標定位到鬧鐘分鐘的位置
  843.                                 LcdPrintNum(Clock_Minute);                // 刷新顯示改變后的鬧鐘分鐘
  844.                                 LcdGotoXY(1,7);                                // 定位光標到鬧鐘分鐘閃爍
  845.                                 DelayMs(300);                                        // 延時0.3秒左右
  846.                         }
  847.                        
  848.                         if(KeyClock_P==0)
  849.                         {
  850.                                 break;
  851.                         }
  852.                 }
  853.                
  854.                 LcdGotoXY(1,12);                                                // 定位光標到鬧鐘開關的位置閃爍
  855.                 DelayMs(10);                                                        // 延時等待，消除按鍵按下的抖動
  856.                 while(!KeyClock_P);                                        // 等待按鍵釋放
  857.                 DelayMs(10);                                                        // 延時等待，消除按鍵松開的抖動
  858.                
  859.                 /* 鬧鐘開關 */
  860.                 while(1)
  861.                 {
  862.                         if(KeyDown_P==0)                                        // 如果減按鍵被下去
  863.                         {
  864.                                 if(Clock_Swt==1)                                // 判斷鬧鐘是否開啟
  865.                                         Clock_Swt=0;                                // 關閉鬧鐘
  866.                                 LcdGotoXY(1,10);                                // 光標定位到秒鐘開關的位置
  867.                                 LcdPrintStr("OFF");                                // 液晶顯示“OFF”
  868.                                 LcdGotoXY(1,12);                                // 定位光標到鬧鐘開關的位置閃爍
  869.                                 DelayMs(300);                                        // 延時0.3秒左右
  870.                         }
  871.                        
  872.                         if(KeyUp_P==0)                                        // 如果加按鍵被下去
  873.                         {
  874.                                 if(Clock_Swt==0)                                // 判斷鬧鐘是否關閉
  875.                                         Clock_Swt=1;                                // 啟動鬧鐘
  876.                                 LcdGotoXY(1,10);                                // 光標定位到秒鐘開關的位置
  877.                                 LcdPrintStr(" ON");                                // 液晶顯示“ ON”
  878.                                 LcdGotoXY(1,12);                                // 定位光標到鬧鐘開關的位置閃爍
  879.                                 DelayMs(300);                                        // 延時0.3秒左右
  880.                         }
  881.                        
  882.                         if(KeyClock_P==0)
  883.                         {
  884.                                 break;
  885.                         }
  886.                 }
  887.                
  888.                 /* 退出前的設置 */
  889.                 LcdWriteCmd(0x0C);                        // 關閉光標閃爍
  890.                 LcdShowInit();                                        // 液晶顯示內容恢復為檢測界面的
  891.                 DelayMs(10);                                        // 延時等待，消除按鍵按下的抖動
  892.                 while(!KeyClock_P);                        // 等待按鍵釋放
  893.                 DelayMs(10);                                        // 延時等待，消除按鍵松開的抖動
  894.                 Sector_Erase(0x2000);
  895.                 EEPROM_Write(0x2000,Clock_Hour);                // 往0x2000這個地址寫入鬧鐘的小時
  896.                 EEPROM_Write(0x2001,Clock_Minute);        // 往0x2001這個地址寫入鬧鐘的分鐘
  897.                 EEPROM_Write(0x2002,Clock_Swt);                // 往0x2002這個地址寫入鬧鐘的開關
  898.         }
  899. }


  902. /*********************************************************/
  903. // 鬧鐘判斷
  904. /*********************************************************/
  905. void ClockJudge()
  906. {
  907.         if(Clock_Swt==1)                        // 判斷鬧鐘的開關是否開啟
  908.         {
  909. // 當前小時和分鐘，和鬧鐘的小時和分鐘是否一致
  910.                 if((Clock_Hour==TimeBuff[4])&&(Clock_Minute==TimeBuff[5]))                                {
  911.                         if(TimeBuff[6]==0)                                        // 秒數是否等于0
  912.                         {
  913.                                 Buzzer_Flag=1;                                // 開啟蜂鳴器報警標志
  914.                         }
  915.                 }
  916.         }
  917.        
  918.         if(TimeBuff[6]==59)                                                        // 如果當前秒數為59秒
  919.         {
  920.                 Buzzer_Flag=0;                                                // 關閉蜂鳴器報警標志
  921.         }
  922.        
  923.         if((KeyDown_P==0)||(KeyUp_P==0))                        // 如果加按鍵或減按鍵被按下
  924.         {
  925.                 Buzzer_Flag=0;                                                // 關閉蜂鳴器報警標志
  926.         }
  927.        
  928.         if(Buzzer_Flag==1)                                                        // 如果蜂鳴器報警標志為啟動
  929.         {
  930.                 Buzzer_P=0;                                                        // 啟動蜂鳴器
  931.                 DelayMs(100);                                                        // 延時0.1秒
  932.                 Buzzer_P=1;                                                        // 關閉蜂鳴器
  933.                 DelayMs(100);                                                        // 延時0.1秒
  934.         }
  935. }


  938. /*********************************************************/
  939. // 主函數
  940. /*********************************************************/
  941. void main()
  942. {
  943.         int temp;                                                        // 保存溫度值

  945.         LcdInit();                                                        // 執行液晶初始化       
  946.         DS1302_Init();                                                // 時鐘芯片的初始化
  947.         LcdShowInit();                                                // 液晶顯示內容的初始化

  949.         if(DS1302_Read_Byte(0x81)>=128)        // 判斷時鐘芯片是否正在運行
  950.         {
  951.                 DS1302_Write_Time();                        // 如果沒有，則初始化一個時間
  952.         }

  954.         Clock_Hour=EEPROM_Read(0x2000);        // 讀取0x2000這個地址的值賦給鬧鐘的小時變量
  955.         if(Clock_Hour>23)                                        // 如果讀取到的鬧鐘小時值不正常，則重新賦值
  956.         {
  957.                 Clock_Hour=12;
  958.         }
  959.           Clock_Minute=EEPROM_Read(0x2001);// 讀取0x2001這個地址的值賦給鬧鐘的分鐘變量
  960.         if(Clock_Minute>59)                                // 如果讀取到的鬧鐘分鐘值不正常，則重新賦值
  961.         {
  962.                 Clock_Minute=30;
  963.         }
  964.         Clock_Swt=EEPROM_Read(0x2002);        // 讀取0x2002這個地址的值賦給鬧鐘的開關變量
  965.         if(Clock_Swt>1)                                        // 如果讀取到的鬧鐘開關值不正常，則重新賦值
  966.         {
  967.                 Clock_Swt=0;
  968.         }
  969. while(DS18B20_ReadTemp()==850)        // 等待溫度傳感器初始化完成
  970.         {
  971.                 DelayMs(10);
  972.         }

  974.         while(1)
  975.         {
  976.                 DS1302_Read_Time();                  // 獲取當前時鐘芯片的時間，存在數組time_buf中
  977.                 FlashTime();                                  // 刷新時間顯示
  978.                 ClockJudge();                                  // 鬧鐘工作的判斷
  979.                
  980.                 temp=DS18B20_ReadTemp();          // 讀取溫度
  981.                 LcdGotoXY(1,9);                          // 定位到顯示溫度的地方
  982.                 LcdPrintTemp(temp);                  // 顯示溫度

  984.                 KeyScanf1();                                  // 按鍵掃描(時間的設置)
  985.                 KeyScanf2();                                  // 按鍵掃描(鬧鐘的設置)
  986.                
  987.                 DelayMs(100);                                  // 延時0.1秒
  988.         }
  989. }
復制代碼


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

使用道具 舉報

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

本版積分規則

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

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板： 国产片侵犯亲女视频播放 | 草久网 | 99精品国产一区二区青青牛奶 | 久久精品免费观看 | 天天爽夜夜爽精品视频婷婷 | 精品久久久久久 | 日韩久久久久 | 91极品视频| 特一级毛片| 欧美日韩不卡 | 欧美一区二区在线观看 | 久久69精品久久久久久久电影好 | 久久久久网站 | 久久一视频 | 久久中文字幕一区 | 五月婷婷导航 | 久久在看 | 色婷婷综合久久久中字幕精品久久 | 色吧久久 | 日本精品久久 | 日韩一区二区三区视频在线观看 | 亚洲欧美日韩久久久 | 欧美综合一区二区三区 | 国产成人久久精品一区二区三区 | 久青草影院 | 毛片免费看 | 福利视频一区二区 | 欧美三区在线观看 | 精品国产乱码久久久久久闺蜜 | 日韩高清中文字幕 | 欧美一区二区三区在线观看视频 | 综合国产在线 | 国产在线精品一区二区 | 久久久成人免费视频 | 亚洲国产aⅴ成人精品无吗 亚洲精品久久久一区二区三区 | 久久无毛 | 欧美精品区| 亚洲欧美日韩在线 | 在线永久看片免费的视频 | 日韩成人在线一区 | 亚洲欧美中文日韩在线v日本 |