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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 基于51单片机的多功能电子时钟设计
返回列表 发新帖
查看: 1224|回复: 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 分享淘帖 顶顶 踩踩
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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