找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2631|回复: 0
打印 上一主题 下一主题
收起左侧

单片机自动打铃系统设计论文下载

[复制链接]
跳转到指定楼层
楼主
ID:342079 发表于 2018-5-31 12:47 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
目录
摘要
关键词
引言
第一章  设计方案论证
1.1 设计要求
1.2 设计方案选择
1.2.1 方案一:数字电路设计的自动打铃系统
1.2.2 方案二:基于单片机的自动打铃系统设计
1.2.3 方案确定
1.3 基本方案
1.3.1 设计课题简要概述
1.3.2 系统软硬件划分
1.3.3 单片机选型
1.4 总体设计框图
第二章  硬件电路设计
2.1 基本原理概述
2.2 主要原件参数及功能简介
2.2.1 主控器AT89C51
2.2.2 时钟电路DS1302
2.3 单元电路的设计
2.3.1显示电路设计
2.3.2 键盘接口电路设计
2.3.3 响铃电路设计
2.4 总体运行进程
第三章  软件电路设计及流程图
3.1 基本原理概述
3.1.1 中断服务程序设计
3.1.2 显示程序设计和按键判断与按键处理程序设计
3.2 流程图
3.2.1 系统主程序流程图
3.2.2 系统定时中断流程图
第四章 系统程序设计
4.1 程序设计概要
4.2 源程序清单
第五章  自动打铃硬件原理图
第六章  毕业设计总结
致谢
参考文献

摘要
自动打铃系统,是以一片8位单片机为核心的实时时钟及控制系统。我们知道单片机的外接石英晶体振荡器能提供稳定、准确的基准频率,并经12分频后向内部定时器提供实时基准频率信号,设定定时器工作在中断方式下,连续对此频率信号进行分频计数,便可得秒信号,再对秒信号进行计数便可得到分、时等实时时钟信息。如果石英晶体振荡器的频率信号为6MHZ,设定定时器定时工作方式1下,定时器为3CBOH,则定时器每100ms产生1次中断,在定时器的中断定时处理程序中,每10次中断,则向秒计数器加1,秒计数器计数到60则向分计数器进位(并建立分进位标志),分计数器计数到60,则向时计数器进位,如此周而复始的连续计数,便可获得时、分、秒的信号,建立一个实时时钟。接下来便可以进行定时处理和打铃输出,当主程序检测到有分进位标志时,便开始比较当前时间(小时与分、存放在RAM中)与信息时间表上的作息时间(小时与分,存放在ROM)是否相同,如有相同者,则进行报时处理并控制打铃,如有不相同则返回主程序,如此便实现了报时控制的要求。

引言

随着科技的不断发展,各种芯片都得到了很好的发展,80C51 同样如此,从开始的无人问津到现在的随处可见,红绿灯,记分牌,电子秒表,遥控器,电饭煲,电视等只要是电子产品,都会和芯片有关,其实芯片并不是什么神秘的高科技,它只是里面装了一些己编好的程序而己.而这里要介绍的是用汇编语言来编程的一个系统,它能够让一个学校或企业集团实现打铃自动化,总之,一个需要时间系统的机构实现自动提醒功能。

当今时代是一个新技术层出不穷的时代,在电子领域尤其是自动化智能控制领域,传统的分立元件或数字逻辑电路构成的控制系统,正以前所未有的速度被单片机智能控制系统所取代。单片机具有体积小、功能强、成本低、应用面广等优点,可以说,智能控制与自动控制的核心就是单片机。目前,一个学习与应用单片机的高潮正在工厂、学校及企事业单位大规模地兴起。而本文是用AT89C51单片机设计的一个自动打铃系统。

第一章  设计方案论证
1.1 设计要求
它可以作为时钟电路来显示时间,进行设置,定时打铃。按照自顶向下设计方法划分自动打铃系统的功能。可分为:时间设置电路,计时电路,显示电路和定时打铃控制电路等。
以江苏信息职业技术学院的打铃情况设计
内容
时间
起床
6:30
早自习
7:30-8:10
第一节课
8:20-9:00
第二节课
9:10-9:50
第三节课
10:00-10:40
第四节课
10:50-11:30
第五节课
13:30-14:10
第六节课
14:20-15:00
第七节课
15:20-16:00
第八节课
16:10-16:50
晚自习
19:00-20:30
熄灯
22:30

1.2 设计方案选择
1.2.1 方案一:数字电路设计的自动打铃系统
利用函数信号发生器来进行脉冲信号输出,利用74160N来设置十进制和六进制的进位输出。利用数码显示器来显示时间,利用或门、与门、非门、与非门、等电路元件进行组合实现打铃的控制。
1.2.2 方案二:基于单片机的自动打铃系统设计
单片机内部存储器设三个字节分别存放时钟的时、分、秒信息。利用定时器与软件结合实现1秒定时中断,没产生一次中断,存储器内相应的秒值加1;若秒值达到60,则将其清零,并将相应的分字节值加1;若分值达到60,则清零分字节,并将时字节值加1;若时值达到24,则将时字节清零。建立完一个实时时钟后接下来进行定时处理和打铃输出,当主程序检测到有分进位标志时,便开始比较当前时间与信息时间表上的作息时间是否相同,相同者,则进行报时处理并控制打铃,不相同则返回主程序。
1.2.3 方案确定
方案一的设计只能事先设定打铃时间不能完全自动打铃,且在修改打铃时间上存在一定的困难。而方案二中的设计能完全实现自动化,诠释了我们这次毕业设计的主题。并在修改打铃时间上有了很大的方便,只需修改一部分程序便能实现不同的需要。
因此我选择方案二进行设计。
1.3 基本方案
1.3.1 设计课题简要概述
自动打铃装置用于工厂、学校等地的时间控制,本设计是按照学校作息时问设定的,模拟了电了钟显示时、分、秒。还根据学校的作息时间按时打铃,本系统有4 个按钮,分别用来调时、调分、秒和强制打铃及强制关铃,以保证始终与标准时间相吻合。
首先设计出本系统的硬件基本框图,根据框图设计电气原理图,简要概述基本原理,按照设计技术参数设计出各部分程序。
1.3.2 系统软硬件划分
由于需要最小系统设计,因此,极大地介于系统的硬件成本,所有能用软件实现的功能都用软件完成,如按键的去抖,采用延时,显示部分用动态显示等,这样硬件部分的设计可以采用单片机最小系统,所谓最小系统时仅有程序存储器和时钟及复位电路的单片机系统。
1.3.3 单片机选型
根据课题的具体内容,任务要求,计时、校时、定时、键盘显示等功能,经多方面考虑,所选系统选项用.与MSC-51单片机完全兼容的AT89C51 低功耗单片机。
1.4 设计框图
图一 整体框图

第二章  硬件电路设计2.1 基本原理概述
本系统主要由主控模块,时钟模块,显示模块,键盘接口模块等4 部分构成。通过内部定时产生中断,从而使驱动电铃打铃。设定51 单片机工作在定时器工作方式1 ,每100ms产生一次中断,利用软件将基准100ms 单元进行累加,当定时器产生10 次中断就产生lS 信号,这是秒单元加1 。同理,对分单元和时单元计数从而产生秒,分,时的值,通过六位七段显示器进行显示。由于动态显示法需要数据所存等硬件,接口较复杂,考虑显示只有六位,且系统没有其他浮躁的处理程序,所有采用动态扫描LED 的显示。
本系统采用四个按键,当时钟时间和设置时间一直时,驱动程序动作,进行打铃,每次打铃30S
2.2 主要原件参数及功能简介2.2.1 主控器AT89C51
AT89C51 公司生产的AT89C51 单片机用高性能的静态89C51 设计,由先进工艺制造,并带有非易失性FLASH 程序存储器,它是· 种高性能、低功耗的8 位CMOS 微处理芯片,市场应用最多,主要特点有:
有4K 的FLASH 程序存储器
256 字节内部RAM
电源控制模式:时钟可停止和恢复,空闲模式,掉电模式
6个中断源
4个中断优先级
4个8位I/O口
全双工增强型UART
2个16位定时、计数器
图二  AT89C51
2.2.2 DS1302
1)性能特性
DS1302与单片机之间能简单地采用同步串行的方式进行通信,仅需用到三个口线:1.RSE复位,2.I/O数据线,3.SCLK 串行时钟。时钟/RAM 的读/写数据以一个字节或多达31 个字节的字符组方式通信。DS1302 工作时功耗很低,保持数据和时钟信息时功率小十1mW 。提供秒分时日日期。月年的信息,每月的天数和闰年的天数可自动调整时钟,操作可通过AM/PM 指示决定采用24 或12 小时格式。
2)管脚描述
XI XZ 32.768KHz 晶振管脚
GND 接地
RST 复位脚
I/O 数据输入/输出引脚
SCLK 串行时钟
Vcc1,Vcc2 电源供电管脚
DS1302 串行时钟芯片8 脚 DIP
DS1302S 串行时钟芯片8 脚 SOIC 200mil
DS1302Z 串行时钟芯片8 脚 SOIC 150mil
图三  DS1302
2.3 单元电路的设计2.3.1显示电路设计
显示部分采用普通的LCD1602显示
图四  显示电路
2.3.2 键盘接口电路设计
由于键盘只有四个,采用独立式按钮,用查询法完成读健功能。


图五  按键电路

2.3.3 响铃电路设计
响铃电路用到了蜂鸣器、三极管、1K电阻。蜂鸣器两端分别接地和三极管。三极管一段电源另一端与电阻相连并接入AT89C51的P3.7接口。
图六  响铃电路
2.4 总体运行进程
首先实现24小时制电子钟,在8位数码管显示,显示为时分秒,实现的格式为:23-59-59。到达预定时间启动蜂鸣器开始打铃,打铃的方式分为起床、熄灯和上下课铃两种。系统使用了4个按键,3只按键用来调整时间,另一只为强制打铃按钮。通过选择键选择调整位,选中位闪烁,按增加键为选中位加1,按减少键为选中位减1。按强制打铃按钮是实现强制打铃或者强制关闭打铃。









第三章  软件电路设计及流程图3.1 基本原理概述
主程序首先是初始化部分,主要是计时单元清零,中断初始化,堆栈指针初始化,启动定时器工作,然后是调用显示子程序。主程序的起始存储地址是0000H单元,但由于本系统用了定时器T0的中断,中断服务程序入口地址为000BH,因此从0000H单元起存放一条短调转指令AJMP,使真正的主程序从0300H单元开始存放。
3.1.1 中断服务程序设计
单片机内部的定时/计数器T0定时100ms,即0.1s,10次中断即为1秒,60秒为1分,60分为1小时,24小时为一天,如此循环,从而实现计时功能。
编写中断服务程序关键要注意:1.现场保护,本系统中是累加器A和程序状态字PSW值的保护。2.计时处理时采用的确十进制,因此时,分,秒单元加1后要进行十进制调整,即要执行DAA指令,还要注意的是时计到24就回零,分和秒计到60就回零。3.中断返回前的现场恢复。
3.1.2 显示程序设计和按键判断与按键处理程序设计
显示采用的是动态显示,段控和位控都经过反相器,显示的字形代码是共阳的显示代码,位控信号输出时是高电平有效,在校时时,采用的是点亮小数点信位调节器标志,哪位小数点亮表示调整的是该为的值。
显示子程序的第一部分是拆字,显示缓冲区是2FH—2AH;第二部分是查字型码,输出段控和位控信号,由于采用的是动态显示,所以每出输出一位的段控和位控信号要延时一定的时间,使LED显示器显示的字符时稳定的。
按键判断程序有编写时应注意按键的去抖动,该系统采用的是延时去抖动的方法,延时是通过调用子程序来实现的,每个按键按下后都要等待释放后再返回。
按键处理程序中的按键式校时的,所以进入按键处理程序后就关闭定时中断,对于动能键注意设置显示标志。
3.2 流程图3.2.1 系统主程序流程图
3.2.2 系统定时中断流程图
第四章 系统程序设计4.1 程序设计概要
程序名称:51 单片机自动扫铃机控制系统
说明:实现24 小时制电子钟,8 位数码管显示,显示时分秒显示格式:23-59-59(小时十位如果为0 则不显示)。
到预定时问启动蜂鸣器模拟打铃,蜂鸣器BEEP: P3.7。
打铃方式分起床、熄幻铃和上、下课铃两种。
系统使用4 只按键,3 只按键用来调整时间,另一只为闹钟按钮即定时扫铃。
键SET_KFY: PI.0;通过选择键选择调整位,选中位闪烁。
增加键ADD_KEY:PI.1;按一次使选中位加1。
减少键DEC_KEY: PI.2;按一次使选中位位。1
如果长按ADD_KEY 或DEC_KEY,识别后则进行调时快进,此时停止闪烁。
如果选中位是秒,则按增加键或减少键都是将秒清零。
定时扫铃键DALING_KEY: P1.3;用来强制打铃或强制关闭铃声PO 口输出数码管段选信号,P2 口输出数码管位选信号。晶振12M

第五章  自动打铃硬件原理图
第六章  毕业设计总结
完成自动打铃系统设计的毕业设计我能综合运用电子技术课程中的所学到的理论知识来完成自动打铃机的设计和分析电路,学会了在虚拟的环境下创建电路,计算和调整参数,我能灵活的应用protcl99se 软件画图,并且掌握了一定的单片片机知识,通过这门课的设计我还有以下几点收获:
1、有利于基础知识的掌握
通过这次设计我亲手做,自己思考,将理论知识上升到实践的高度,从而进一步打破了单片机的神秘面纱。
2、有利于逻辑思维的锻炼。
在许多常规可生的日常学习中我们不难发现这样一个现象,不少学生的思维常处于混乱的状态,写作文来前言不搭后语,解起数学题来步骤混乱,这些都是缺乏思维训练的结果,程序设计是公认的,最能直接有效的训练学生的创造思维,培养分析问题解决问题的能力的方法之一。即使见到陌生的程序,从任务分析,确定算法界面布局,缩写代码到调试运行,都能顺利完成。
整个过程需要我们有条理的构思,这之间有猜测设计,判断思维的抽象思维训练,又有分析问题解决问题,预测日标等能力的培养。
致谢
在本文的撰写过程中,导师王琦华给予了悉心的指导和关心,使我克服了众多困难终于完成了毕业设计的撰写工作。导师渊博的知识、严谨求实的治学态度及敬业精神,给我留下了深刻的印象,并将在我今后的人生道路上产生深远的影响,在此论文完成之际,谨向导师致以崇高的敬意和衷心的感谢!
再一次感谢所有关心我、帮助我的人!

单片机源程序如下:
  1. #include <reg52.h>                       //调用单片机头文件
  2. #define uchar unsigned char  //无符号字符型 宏定义              变量范围0~255
  3. #define uint  unsigned int              //无符号整型 宏定义              变量范围0~65535
  4. #include "eeprom52.h"

  5. bit flag_200ms ;
  6. bit flag_100ms ;
  7. sbit beep = P3^7;                //蜂鸣器定义
  8. bit flag_beep_en;
  9. uint clock_value;     //用作闹钟用的

  10. uchar menu_1,menu_2;

  11. uchar key_time,flag_value;      //用做连加的中间变量
  12. bit key_500ms  ;

  13. //#include "key.h"
  14. #include "ds1302.h"
  15. #include "lcd1602.h"

  16. uchar fen1=0x30,shi1=0x06;                //第1个打铃的时间                            起床
  17. uchar fen2=0x30,shi2=0x07;                //第2个打铃的时间                            早自习
  18. uchar fen3=0x10,shi3=0x08;                //第3个打铃的时间                            早自习下         
  19. uchar fen4=0x20,shi4=0x08;                //第4个打铃的时间                            第一节上课   
  20. uchar fen5=0x00,shi5=0x09;                //第5个打铃的时间                            第一节下课
  21. uchar fen6=0x10,shi6=0x09;                //第6个打铃的时间                            第二节上课     
  22. uchar fen7=0x50,shi7=0x09;                //第7个打铃的时间                            第二节下课  
  23. uchar fen8=0x00,shi8=0x10;                //第8个打铃的时间                            第三节上课  
  24. uchar fen9=0x40,shi9=0x10;                //第9个打铃的时间                            第三节下课
  25. uchar fen10=0x50,shi10=0x10;                //第10个打铃的时间 第四节上课
  26. uchar fen11=0x30,shi11=0x11;                //第11个打铃的时间 第四节下课
  27. uchar fen12=0x30,shi12=0x13;                //第12个打铃的时间 第五节上课
  28. uchar fen13=0x10,shi13=0x14;                //第13个打铃的时间 第五节下课
  29. uchar fen14=0x20,shi14=0x14;                //第14个打铃的时间 第六节上课
  30. uchar fen15=0x00,shi15=0x15;                //第15个打铃的时间 第六节下课
  31. uchar fen16=0x20,shi16=0x15;                //第16个打铃的时间 第七节上课
  32. uchar fen17=0x00,shi17=0x16;                //第17个打铃的时间 第七节下课
  33. uchar fen18=0x10,shi18=0x16;                //第18个打铃的时间 第八节上课
  34. uchar fen19=0x50,shi19=0x16;                //第19个打铃的时间 第八节下课
  35. uchar fen20=0x00,shi20=0x19;                //第20个打铃的时间 晚自习上课
  36. uchar fen21=0x30,shi21=0x20;                //第21个打铃的时间 晚自习下课
  37. uchar fen22=0x30,shi22=0x22;                //第22个打铃的时间 熄灯
  38. uchar fen23=0x00,shi23=0x00;                //第23个打铃的时间
  39. uchar fen24=0x00,shi24=0x00;                //第24个打铃的时间
  40. uchar fen25=0x00,shi25=0x00;                //第25个打铃的时间
  41. uchar fen26=0x00,shi26=0x00;                //第26个打铃的时间


  42. /******************把数据保存到单片机内部eeprom中******************/
  43. void write_eeprom()
  44. {
  45.               SectorErase(0x2000);
  46.               byte_write(0x2000, fen1);                 //第1个打铃的时间
  47.               byte_write(0x2001, shi1);
  48.               byte_write(0x2002, fen2);                 //第2个打铃的时间
  49.               byte_write(0x2003, shi2);
  50.               byte_write(0x2004, fen3);                 //第3个打铃的时间
  51.               byte_write(0x2005, shi3);
  52.               byte_write(0x2006, fen4);                 //第4个打铃的时间
  53.               byte_write(0x2007, shi4);
  54.               byte_write(0x2008, fen5);                 //第5个打铃的时间
  55.               byte_write(0x2009, shi5);
  56.               byte_write(0x2010, fen6);                 //第6个打铃的时间
  57.               byte_write(0x2011, shi6);
  58.               byte_write(0x2012, fen7);                 //第7个打铃的时间
  59.               byte_write(0x2013, shi7);
  60.               byte_write(0x2014, fen8);                 //第8个打铃的时间
  61.               byte_write(0x2015, shi8);
  62.               byte_write(0x2016, fen9);                 //第9个打铃的时间
  63.               byte_write(0x2017, shi9);
  64.               byte_write(0x2018, fen10);                 //第10个打铃的时间
  65.               byte_write(0x2019, shi10);
  66.               byte_write(0x2020, fen11);                 //第11个打铃的时间
  67.               byte_write(0x2021, shi11);
  68.               byte_write(0x2022, fen12);                 //第12个打铃的时间
  69.               byte_write(0x2023, shi12);
  70.               byte_write(0x2024, fen13);                 //第13个打铃的时间
  71.               byte_write(0x2025, shi13);
  72.               byte_write(0x2026, fen14);                 //第14个打铃的时间
  73.               byte_write(0x2027, shi14);
  74.               byte_write(0x2028, fen15);                 //第15个打铃的时间
  75.               byte_write(0x2029, shi15);                              
  76.               byte_write(0x2030, fen16);                 //第16个打铃的时间
  77.               byte_write(0x2031, shi16);
  78.               byte_write(0x2032, fen17);                 //第17个打铃的时间
  79.               byte_write(0x2033, shi17);
  80.               byte_write(0x2034, fen18);                 //第18个打铃的时间
  81.               byte_write(0x2035, shi18);
  82.               byte_write(0x2036, fen19);                 //第19个打铃的时间
  83.               byte_write(0x2037, shi19);
  84.               byte_write(0x2038, fen20);                 //第20个打铃的时间
  85.               byte_write(0x2039, shi20);
  86.               byte_write(0x2040, fen21);                 //第21个打铃的时间
  87.               byte_write(0x2041, shi21);
  88.               byte_write(0x2042, fen22);                 //第22个打铃的时间
  89.               byte_write(0x2043, shi22);
  90.               byte_write(0x2044, fen23);                 //第23个打铃的时间
  91.               byte_write(0x2045, shi23);
  92.               byte_write(0x2046, fen24);                 //第24个打铃的时间
  93.               byte_write(0x2047, shi24);                                                                                   
  94.               byte_write(0x2048, fen25);                 //第25个打铃的时间
  95.               byte_write(0x2049, shi25);                                                                                   
  96.               byte_write(0x2050, fen26);                 //第26个打铃的时间
  97.               byte_write(0x2051, shi26);                                                                                   
  98.               byte_write(0x2058, a_a);            
  99. }

  100. /******************把数据从单片机内部eeprom中读出来*****************/
  101. void read_eeprom()
  102. {
  103.               fen1  = byte_read(0x2000);                //第1个打铃的时间
  104.               shi1  = byte_read(0x2001);
  105.               fen2  = byte_read(0x2002);                //第2个打铃的时间
  106.               shi2  = byte_read(0x2003);
  107.               fen3  = byte_read(0x2004);                //第3个打铃的时间
  108.               shi3  = byte_read(0x2005);
  109.               fen4  = byte_read(0x2006);                //第4个打铃的时间
  110.               shi4  = byte_read(0x2007);
  111.               fen5  = byte_read(0x2008);                //第5个打铃的时间
  112.               shi5  = byte_read(0x2009);
  113.               fen6  = byte_read(0x2010);                //第6个打铃的时间
  114.               shi6  = byte_read(0x2011);
  115.               fen7  = byte_read(0x2012);                //第7个打铃的时间
  116.               shi7  = byte_read(0x2013);
  117.               fen8  = byte_read(0x2014);                //第8个打铃的时间
  118.               shi8  = byte_read(0x2015);
  119.               fen9  = byte_read(0x2016);                //第9个打铃的时间
  120.               shi9  = byte_read(0x2017);
  121.               fen10  = byte_read(0x2018);                //第10个打铃的时间
  122.               shi10  = byte_read(0x2019);
  123.               fen11  = byte_read(0x2020);                //第11个打铃的时间
  124.               shi11  = byte_read(0x2021);
  125.               fen12  = byte_read(0x2022);                //第12个打铃的时间
  126.               shi12  = byte_read(0x2023);
  127.               fen13  = byte_read(0x2024);                //第13个打铃的时间
  128.               shi13  = byte_read(0x2025);
  129.               fen14  = byte_read(0x2026);                //第14个打铃的时间
  130.               shi14  = byte_read(0x2027);
  131.               fen15  = byte_read(0x2028);                //第15个打铃的时间
  132.               shi15  = byte_read(0x2029);
  133.               fen16  = byte_read(0x2030);                //第16个打铃的时间
  134.               shi16 = byte_read(0x2031);
  135.               fen17  = byte_read(0x2032);                //第17个打铃的时间
  136.               shi17  = byte_read(0x2033);
  137.               fen18  = byte_read(0x2034);                //第18个打铃的时间
  138.               shi18  = byte_read(0x2035);
  139.               fen19  = byte_read(0x2036);                //第19个打铃的时间
  140.               shi19  = byte_read(0x2037);
  141.               fen20  = byte_read(0x2038);                //第20个打铃的时间
  142.               shi20  = byte_read(0x2039);
  143.               fen21  = byte_read(0x2040);                //第21个打铃的时间
  144.               shi21  = byte_read(0x2041);
  145.               fen22  = byte_read(0x2042);                //第22个打铃的时间
  146.               shi22  = byte_read(0x2043);
  147.               fen23  = byte_read(0x2044);                //第23个打铃的时间
  148.               shi23  = byte_read(0x2045);
  149.               fen24  = byte_read(0x2046);                //第24个打铃的时间
  150.               shi24  = byte_read(0x2047);
  151.               fen25  = byte_read(0x2048);                //第25个打铃的时间
  152.               shi25  = byte_read(0x2049);
  153.               fen26  = byte_read(0x2050);                //第26个打铃的时间
  154.               shi26  = byte_read(0x2051);
  155.               a_a      = byte_read(0x2058);
  156. }

  157. /**************开机自检eeprom初始化*****************/
  158. void init_eeprom()
  159. {
  160.               read_eeprom();                            //先读
  161.               if(a_a != 2)                            //新的单片机初始单片机内问eeprom
  162.               {
  163.                             a_a = 2;
  164.                             fen1=0x30,shi1=0x06;                //第1个打铃的时间                            起床
  165.                             fen2=0x30,shi2=0x07;                //第2个打铃的时间                            早自习
  166.                             fen3=0x10,shi3=0x08;                //第3个打铃的时间                            早自习下         
  167.                             fen4=0x20,shi4=0x08;                //第4个打铃的时间                            第一节上课   
  168.                             fen5=0x00,shi5=0x09;                //第5个打铃的时间                            第一节下课
  169.                             fen6=0x10,shi6=0x09;                //第6个打铃的时间                            第二节上课     
  170.                             fen7=0x50,shi7=0x09;                //第7个打铃的时间                            第二节下课  
  171.                             fen8=0x00,shi8=0x10;                //第8个打铃的时间                            第三节上课  
  172.                             fen9=0x40,shi9=0x10;                //第9个打铃的时间                            第三节下课
  173.                             fen10=0x50,shi10=0x10;                //第10个打铃的时间 第四节上课
  174.                             fen11=0x30,shi11=0x11;                //第11个打铃的时间 第四节下课
  175.                             fen12=0x30,shi12=0x13;                //第12个打铃的时间 第五节上课
  176.                             fen13=0x10,shi13=0x14;                //第13个打铃的时间 第五节下课
  177.                             fen14=0x20,shi14=0x14;                //第14个打铃的时间 第六节上课
  178.                             fen15=0x00,shi15=0x15;                //第15个打铃的时间 第六节下课
  179.                             fen16=0x20,shi16=0x15;                //第16个打铃的时间 第七节上课
  180.                             fen17=0x00,shi17=0x16;                //第17个打铃的时间 第七节下课
  181.                             fen18=0x10,shi18=0x16;                //第18个打铃的时间 第八节上课
  182.                             fen19=0x50,shi19=0x16;                //第19个打铃的时间 第八节下课
  183.                             fen20=0x00,shi20=0x19;                //第20个打铃的时间 晚自习上课
  184.                             fen21=0x30,shi21=0x20;                //第21个打铃的时间 晚自习下课
  185.                             fen22=0x30,shi22=0x22;                //第22个打铃的时间 熄灯
  186.                             fen23=0x00,shi23=0x00;                //第23个打铃的时间
  187.                             fen24=0x00,shi24=0x00;                //第24个打铃的时间
  188.                             fen25=0x00,shi25=0x00;                //第25个打铃的时间
  189.                             fen26=0x00,shi26=0x00;                //第25个打铃的时间
  190.                             write_eeprom();                 //保存数据
  191.               }            
  192. }


  193. /******************1ms 延时函数*******************/
  194. void delay_1ms(uint q)
  195. {
  196.               uint i,j;
  197.               for(i=0;i<q;i++)
  198.                             for(j=0;j<120;j++);
  199. }

  200. /*************定时器0初始化程序***************/
  201. void init_1602_ds1302()
  202. {
  203.               write_sfm2_ds1302(2,3,nian);            
  204.               write_sfm2_ds1302(2,6,yue);            
  205.               write_sfm2_ds1302(2,9,ri);            
  206.               write_sfm2_ds1302(1,2,shi);            
  207.               write_sfm2_ds1302(1,5,fen);            
  208.               write_sfm2_ds1302(1,8,miao);
  209.               write_sfm1(1,14,week);                           
  210. }                                                                                                                                

  211. /*************定时器0初始化程序***************/
  212. void init_time0()               
  213. {
  214.               EA   = 1;                              //开总中断
  215.               TMOD = 0X01;                //定时器0、工作方式1
  216.               ET0  = 1;                              //开定时器0中断
  217.               TR0  = 1;                              //允许定时器0定时
  218. }

  219. /*************闹钟报警函数***************/
  220. void menu_dis()
  221. {
  222.               static uchar mm,value;
  223.               if(flag_100ms == 1)                              //100ms执行一次
  224.               {
  225.                             flag_100ms = 0;
  226.                             {            
  227.                                           if(miao == 0)
  228.                                           if(((fen == fen1) && (shi == shi1) && (shi1 != 0)) ||
  229.                                              ((fen == fen2) && (shi == shi2) && (shi2 != 0)) ||              //第2个打铃时间判断
  230.                                              ((fen == fen3) && (shi == shi3) && (shi3 != 0)) ||              //第3个打铃时间判断
  231.                                              ((fen == fen4) && (shi == shi4) && (shi4 != 0)) ||              //第4个打铃时间判断
  232.                                              ((fen == fen5) && (shi == shi5) && (shi5 != 0)) ||              //第5个打铃时间判断
  233.                                              ((fen == fen6) && (shi == shi6) && (shi6 != 0)) ||              //第6个打铃时间判断
  234.                                              ((fen == fen7) && (shi == shi7) && (shi7 != 0)) ||              //第7个打铃时间判断
  235.                                              ((fen == fen8) && (shi == shi8) && (shi8 != 0)) ||              //第8个打铃时间判断
  236.                                              ((fen == fen9) && (shi == shi9) && (shi9 != 0)) ||              //第9个打铃时间判断
  237.                                              ((fen == fen10) && (shi == shi10) && (shi10 != 0)) ||              //第10个打铃时间判断
  238.                                              ((fen == fen11) && (shi == shi11) && (shi11 != 0)) ||              //第11个打铃时间判断
  239.                                              ((fen == fen12) && (shi == shi12) && (shi12 != 0)) ||              //第12个打铃时间判断
  240.                                              ((fen == fen13) && (shi == shi13) && (shi13 != 0)) ||              //第13个打铃时间判断
  241.                                              ((fen == fen14) && (shi == shi14) && (shi14 != 0)) ||              //第14个打铃时间判断
  242.                                              ((fen == fen15) && (shi == shi15) && (shi15 != 0)) ||              //第15个打铃时间判断
  243.                                              ((fen == fen16) && (shi == shi16) && (shi16 != 0)) ||              //第16个打铃时间判断
  244.                                              ((fen == fen17) && (shi == shi17) && (shi17 != 0)) ||              //第17个打铃时间判断
  245.                                              ((fen == fen18) && (shi == shi18) && (shi18 != 0)) ||              //第18个打铃时间判断
  246.                                              ((fen == fen19) && (shi == shi19) && (shi19 != 0)) ||              //第19个打铃时间判断
  247.                                              ((fen == fen20) && (shi == shi20) && (shi20 != 0)) ||              //第20个打铃时间判断
  248.                                              ((fen == fen21) && (shi == shi21) && (shi21 != 0)) ||              //第21个打铃时间判断
  249.                                              ((fen == fen22) && (shi == shi22) && (shi22 != 0)) ||              //第22个打铃时间判断
  250.                                              ((fen == fen23) && (shi == shi23) && (shi23 != 0)) ||              //第23个打铃时间判断
  251.                                              ((fen == fen24) && (shi == shi24) && (shi24 != 0)) ||              //第24个打铃时间判断
  252.                                              ((fen == fen25) && (shi == shi25) && (shi25 != 0)) ||              //第25个打铃时间判断
  253.                                              ((fen == fen26) && (shi == shi26) && (shi26 != 0))               //第26个打铃时间判断
  254.                                                         )
  255.                                                         flag_beep_en = 1;              //打铃蜂鸣器响的标志位                                                      
  256.                                           if(flag_beep_en == 1)              //打铃以被打开
  257.                                           {
  258.                                                         clock_value++;
  259.                                                         beep = ~beep;                 //蜂鸣器叫3秒
  260.                                                         //  15 秒后自动关闭闹钟
  261.                                                         value ++;
  262.                                                         if(value >= 10)
  263.                                                         {
  264.                                                                       value = 0;
  265.                                                                       mm++;
  266.                                                                       if(mm >= 15)
  267.                                                                       {
  268.                                                                                     mm = 0;
  269.                                                                                     flag_beep_en = 0;
  270.                                                                                     beep = 1;
  271.                                                                       }
  272.                                                         }                                                                     
  273.                                           }
  274.                             }            
  275.               }
  276. }


  277. /********************独立按键程序*****************/
  278. uchar key_can;              //按键值

  279. void key()              //独立按键程序
  280. {
  281.               static uchar key_new;
  282.               key_can = 20;                   //按键值还原
  283.               P3 |= 0x78;                     //对应的按键IO口输出为1
  284.               if((P3 & 0x78) != 0x78)                            //按键按下
  285.               {
  286.                             delay_1ms(1);                                 //按键消抖动
  287.                             if(((P3 & 0x78) != 0x78) && (key_new == 1))
  288.                             {                                                                                    //确认是按键按下
  289.                                           key_new = 0;
  290.                                           switch(P3 & 0x78)
  291.                                           {
  292.                                                         case 0x70:  key_can = 4;  break;              //得到按键值
  293.                                                         case 0x68:  key_can = 3;  break;              //得到按键值
  294.                                                         case 0x58:  key_can = 2;  break;              //得到按键值
  295.                                                         case 0x38:  key_can = 1;  break;              //得到按键值
  296.                                           }
  297. //                                          write_sfm2(1,0,key_can);                                                        //显示按键值
  298.                             }                                         
  299.               }
  300.               else
  301.                             key_new = 1;            
  302. }


  303. /**********************设置函数************************/
  304. void key_with()
  305. {
  306.               if(key_can == 1)              //设置键
  307.               {
  308.                             menu_1++;
  309.                             if(menu_1 == 1)                //设置时间
  310.                             {
  311.                                           menu_2 = 1;
  312.                                           write_string(1,0,"    -  -    W:  ");                                         
  313.                                           write_string(2,0," 20  -  -       ");            
  314.                             }
  315.                             menu_2 = 1;
  316.                             if(menu_1 > 15)    //回到正常显示
  317.                             {
  318.                                           menu_1 = 0;
  319.                                           write_guanbiao(1,2,0);                //关闭光标
  320.                                           init_1602_dis_csf();      //初始化液晶显示                           
  321.                             }
  322.               }
  323.               if(key_can == 2)              //选择键
  324.               {
  325.                             flag_200ms = 1;
  326.                             if(menu_1 == 1)                              //设置时间
  327.                             {
  328.                                           menu_2 ++;
  329.                                           if(menu_2 > 7)
  330.                                                         menu_2 = 1;
  331.                             }
  332.                             if(menu_1 != 1)                            //设置
  333.                             {
  334.                                           menu_2 ++;
  335.                                           if(menu_2 > 4)
  336.                                                         menu_2 = 1;                                                      
  337.                             }
  338.               }
  339.               if(menu_1 == 1)
  340.               {
  341.                             if(menu_2 == 1)                              //设置时
  342.                             {
  343.                                           if(key_can == 3)              //加
  344.                                           {
  345.                                                         shi+=0x01;
  346.                                                         if((shi & 0x0f) >= 0x0a)
  347.                                                                       shi = (shi & 0xf0) + 0x10;
  348.                                                         if(shi >= 0x24)
  349.                                                                       shi = 0;
  350.                                           }                           
  351.                                           if(key_can == 4)              //减
  352.                                           {
  353.                                                         if(shi == 0x00)
  354.                                                                       shi = 0x24;
  355.                                                         if((shi & 0x0f) == 0x00)
  356.                                                                       shi = (shi | 0x0a) - 0x10;
  357.                                                         shi -- ;
  358.                                           }                                                                       
  359.                             }
  360.                             if(menu_2 == 2)                              //设置分
  361.                             {
  362.                                           if(key_can == 3)              //加
  363.                                           {
  364.                                                         fen+=0x01;
  365.                                                         if((fen & 0x0f) >= 0x0a)
  366.                                                                       fen = (fen & 0xf0) + 0x10;
  367.                                                         if(fen >= 0x60)
  368.                                                                       fen = 0;
  369.                                           }                           
  370.                                           if(key_can == 4)              //减               
  371.                                           {
  372.                                                         if(fen == 0x00)
  373.                                                                       fen = 0x5a;
  374.                                                         if((fen & 0x0f) == 0x00)
  375.                                                                       fen = (fen | 0x0a) - 0x10;
  376.                                                         fen -- ;
  377.                                           }            
  378.                             }
  379.                             if(menu_2 == 3)                              //设置秒
  380.                             {
  381.                                           if(key_can == 3)              //加
  382.                                           {
  383.                                                         miao+=0x01;
  384.                                                         if((miao & 0x0f) >= 0x0a)
  385.                                                                       miao = (miao & 0xf0) + 0x10;
  386.                                                         if(miao >= 0x60)
  387.                                                                       miao = 0;
  388.                                           }            
  389.                                           if(key_can == 4)              //减               
  390.                                           {
  391.                                                         if(miao == 0x00)
  392.                                                                       miao = 0x5a;
  393.                                                         if((miao & 0x0f) == 0x00)
  394.                                                                       miao = (miao | 0x0a) - 0x10;
  395.                                                         miao -- ;                                         
  396.                                           }
  397.                             }
  398.                             if(menu_2 == 4)                              //设置星期
  399.                             {
  400.                                           if(key_can == 3)              //加
  401.                                           {
  402.                                               week+=0x01;
  403.                                                         if((week & 0x0f) >= 0x0a)
  404.                                                                       week = (week & 0xf0) + 0x10;
  405.                                                         if(week >= 0x08)
  406.                                                                       week = 1;
  407.                                           }                           
  408.                                           if(key_can == 4)              //减               
  409.                                           {
  410.                                                         if(week == 0x01)
  411.                                                                       week = 0x08;
  412.                                                         if((week & 0x0f) == 0x00)
  413.                                                                       week = (week | 0x0a) - 0x10;
  414.                                                         week -- ;
  415.                                           }            
  416.                             }
  417.                             if(menu_2 == 5)                              //设置年
  418.                             {
  419.                                           if(key_can == 3)              //加
  420.                                           {
  421.                                               nian+=0x01;
  422.                                                         if((nian & 0x0f) >= 0x0a)
  423.                                                                       nian = (nian & 0xf0) + 0x10;
  424.                                                         if(nian >= 0x9a)
  425.                                                                       nian = 1;
  426.                                           }                           
  427.                                           if(key_can == 4)              //减               
  428.                                           {
  429.                                                         if(nian == 0x01)
  430.                                                                       nian = 0x9a;
  431.                                                         if((nian & 0x0f) == 0x00)
  432.                                                                       nian = (nian | 0x0a) - 0x10;
  433.                                                         nian -- ;                           
  434.                                           }            
  435.                             }
  436.                             if(menu_2 == 6)                              //设置月
  437.                             {
  438.                                           if(key_can == 3)              //加
  439.                                           {
  440.                                               yue+=0x01;
  441.                                                         if((yue & 0x0f) >= 0x0a)
  442.                                                                       yue = (yue & 0xf0) + 0x10;
  443.                                                         if(yue >= 0x13)
  444.                                                                       yue = 1;
  445.                                           }                           
  446.                                           if(key_can == 4)              //减               
  447.                                           {
  448.                                                         if(yue == 0x01)
  449.                                                                       yue = 0x13;
  450.                                                         if((yue & 0x0f) == 0x00)
  451.                                                                       yue = (yue | 0x0a) - 0x10;
  452.                                                         yue -- ;                                                                     
  453.                                           }            
  454.                             }
  455.                             if(menu_2 == 7)                              //设置日
  456.                             {
  457.                                           if(key_can == 3)              //加
  458.                                           {
  459.                                 ri+=0x01;
  460.                                           if((ri & 0x0f) >= 0x0a)
  461.                                                         ri = (ri & 0xf0) + 0x10;
  462.                                           if(ri >= 0x32)
  463.                                                         ri = 0;                                         
  464.                                           }                           
  465.                                           if(key_can == 4)              //减               
  466.                                           {
  467.                                                         if(ri == 0x01)
  468.                                                                       ri = 0x32;
  469.                                                         if((ri & 0x0f) == 0x00)
  470.                                                                       ri = (ri | 0x0a) - 0x10;
  471.                                                         ri -- ;                                         
  472.                                           }            
  473.                             }
  474.                             write_sfm2_ds1302(1,2,shi);                 //显示时
  475.                             write_sfm2_ds1302(1,5,fen);                 //显示分
  476.                             write_sfm2_ds1302(1,8,miao);                 //显示秒
  477.                             write_sfm1(1,14,week);                 //显示星期                                                                     
  478.                             write_sfm2_ds1302(2,3,nian);                 //显示年
  479.                             write_sfm2_ds1302(2,6,yue);                 //显示月
  480.                             write_sfm2_ds1302(2,9,ri);                 //显示日
  481.                             switch(menu_2)                 // 光标显示
  482.                             {
  483.                                           case 1:  write_guanbiao(1,2,1);  break;
  484.                                           case 2:  write_guanbiao(1,5,1);  break;
  485.                                           case 3:  write_guanbiao(1,8,1);  break;
  486.                                           case 4:  write_guanbiao(1,14,1); break;
  487.                                           case 5:  write_guanbiao(2,3,1);  break;
  488.                                           case 6:  write_guanbiao(2,6,1);  break;
  489.                                           case 7:  write_guanbiao(2,9,1);  break;
  490.                             }
  491.                             write_time();                 //把时间写进去
  492.               }            
  493. /***************设置1 2打铃时间*********************/
  494.               if(menu_1 == 2)
  495.               {            
  496. /////////////////////                 第1个打铃时间
  497.                             if(menu_2 == 1)                              //设置打铃时
  498.                             {
  499.                                           if(key_can == 3)              //加            
  500.                                                         set_ds1302time(1,&shi1,0x24);                           
  501.                                           if(key_can == 4)              //减               
  502.                                                         set_ds1302time(0,&shi1,0x24);                           
  503.                             }
  504.                             if(menu_2 == 2)                              //设
  505.                             {
  506.                                           if(key_can == 3)              //加
  507.                                                         set_ds1302time(1,&fen1,0x60);                           
  508.                                           if(key_can == 4)              //减               
  509.                                                         set_ds1302time(0,&fen1,0x60);                           
  510.                             }            
  511. /////////////////////                 第2个打铃时间            
  512.                             if(menu_2 == 3)                              //设置打铃分
  513.                             {
  514.                                           if(key_can == 3)              //加              第2个打铃时间
  515.                                                         set_ds1302time(1,&shi2,0x24);                           
  516.                                           if(key_can == 4)              //减               
  517.                                                         set_ds1302time(0,&shi2,0x24);                           
  518.                             }
  519.                             if(menu_2 == 4)                              //设
  520.                             {
  521.                                           if(key_can == 3)              //加
  522.                                                         set_ds1302time(1,&fen2,0x60);                           
  523.                                           if(key_can == 4)              //减               
  524.                                                         set_ds1302time(0,&fen2,0x60);                           
  525.                             }
  526.                             write_string(1,0," set1 00:00    ");                                         
  527.                             write_string(2,0," set2 00:00      ");            
  528.                             write_sfm2_ds1302(1,6,shi1);                 //显示时
  529.                             write_sfm2_ds1302(1,9,fen1);                 //显示分
  530.                             write_sfm2_ds1302(2,6,shi2);                 //显示时
  531.                             write_sfm2_ds1302(2,9,fen2);                 //显示分
  532.                             switch(menu_2)                 // 光标显示
  533.                             {
  534.                                           case 1:  write_guanbiao(1,6,1);  break;
  535.                                           case 2:  write_guanbiao(1,9,1);  break;
  536.                                           case 3:  write_guanbiao(2,6,1);  break;
  537.                                           case 4:  write_guanbiao(2,9,1);  break;
  538.                             }            
  539.                             write_eeprom();     //保存闹钟时间
  540.               }            
  541. /***************设置3 4打铃时间*********************/
  542.               if(menu_1 == 3)
  543.               {            
  544. /////////////////////                 第1个打铃时间
  545.                             if(menu_2 == 1)                              //设置打铃时
  546.                             {
  547.                                           if(key_can == 3)              //加            
  548.                                                         set_ds1302time(1,&shi3,0x24);                           
  549.                                           if(key_can == 4)              //减               
  550.                                                         set_ds1302time(0,&shi3,0x24);                           
  551.                             }
  552.                             if(menu_2 == 2)                              //设
  553.                             {
  554.                                           if(key_can == 3)              //加
  555.                                                         set_ds1302time(1,&fen3,0x60);                           
  556.                                           if(key_can == 4)              //减               
  557.                                                         set_ds1302time(0,&fen3,0x60);                           
  558.                             }            
  559. /////////////////////                 第2个打铃时间            
  560.                             if(menu_2 == 3)                              //设置打铃分
  561.                             {
  562.                                           if(key_can == 3)              //加              第2个打铃时间
  563.                                                         set_ds1302time(1,&shi4,0x24);                           
  564.                                           if(key_can == 4)              //减               
  565.                                                         set_ds1302time(0,&shi4,0x24);                           
  566.                             }
  567.                             if(menu_2 == 4)                              //设
  568.                             {
  569.                                           if(key_can == 3)              //加
  570.                                                         set_ds1302time(1,&fen4,0x60);                           
  571.                                           if(key_can == 4)              //减               
  572.                                                         set_ds1302time(0,&fen4,0x60);                           
  573.                             }
  574.                             write_string(1,0," set3 00:00    ");                                         
  575.                             write_string(2,0," set4 00:00      ");            
  576.                             write_sfm2_ds1302(1,6,shi3);                 //显示时
  577.                             write_sfm2_ds1302(1,9,fen3);                 //显示分
  578.                             write_sfm2_ds1302(2,6,shi4);                 //显示时
  579.                             write_sfm2_ds1302(2,9,fen4);                 //显示分
  580.                             switch(menu_2)                 // 光标显示
  581.                             {
  582.                                           case 1:  write_guanbiao(1,6,1);  break;
  583.                                           case 2:  write_guanbiao(1,9,1);  break;
  584.                                           case 3:  write_guanbiao(2,6,1);  break;
  585.                                           case 4:  write_guanbiao(2,9,1);  break;
  586.                             }            
  587.                             write_eeprom();     //保存闹钟时间
  588.               }            
  589. /***************设置5 6打铃时间*********************/
  590.               if(menu_1 == 4)
  591.               {            
  592. /////////////////////                 第5个打铃时间
  593.                             if(menu_2 == 1)                              //设置打铃时
  594.                             {
  595.                                           if(key_can == 3)              //加            
  596.                                                         set_ds1302time(1,&shi5,0x24);                           
  597.                                           if(key_can == 4)              //减               
  598.                                                         set_ds1302time(0,&shi5,0x24);                           
  599.                             }
  600.                             if(menu_2 == 2)                              //设
  601.                             {
  602.                                           if(key_can == 3)              //加
  603.                                                         set_ds1302time(1,&fen5,0x60);                           
  604.                                           if(key_can == 4)              //减               
  605.                                                         set_ds1302time(0,&fen5,0x60);                           
  606.                             }            
  607. /////////////////////                 第6个打铃时间            
  608.                             if(menu_2 == 3)                              //设置打铃分
  609.                             {
  610.                                           if(key_can == 3)              //加            
  611.                                                         set_ds1302time(1,&shi6,0x24);                           
  612.                                           if(key_can == 4)              //减               
  613.                                                         set_ds1302time(0,&shi6,0x24);                           
  614.                             }
  615.                             if(menu_2 == 4)                              //设
  616.                             {
  617.                                           if(key_can == 3)              //加
  618.                                                         set_ds1302time(1,&fen6,0x60);                           
  619.                                           if(key_can == 4)              //减               
  620.                                                         set_ds1302time(0,&fen6,0x60);                           
  621.                             }
  622.                             write_string(1,0," set5 00:00    ");                                         
  623.                             write_string(2,0," set6 00:00      ");            
  624.                             write_sfm2_ds1302(1,6,shi5);                 //显示时
  625.                             write_sfm2_ds1302(1,9,fen5);                 //显示分
  626.                             write_sfm2_ds1302(2,6,shi6);                 //显示时
  627.                             write_sfm2_ds1302(2,9,fen6);                 //显示分
  628.                             switch(menu_2)                 // 光标显示
  629.                             {
  630.                                           case 1:  write_guanbiao(1,6,1);  break;
  631.                                           case 2:  write_guanbiao(1,9,1);  break;
  632.                                           case 3:  write_guanbiao(2,6,1);  break;
  633.                                           case 4:  write_guanbiao(2,9,1);  break;
  634.                             }            
  635.                             write_eeprom();     //保存闹钟时间
  636.               }            
  637. /***************设置7 8打铃时间*********************/
  638.               if(menu_1 == 5)
  639.               {            
  640. /////////////////////                 第7个打铃时间
  641.                             if(menu_2 == 1)                              //设置打铃时
  642.                             {
  643.                                           if(key_can == 3)              //加            
  644.                                                         set_ds1302time(1,&shi7,0x24);                           
  645.                                           if(key_can == 4)              //减               
  646.                                                         set_ds1302time(0,&shi7,0x24);                           
  647.                             }
  648.                             if(menu_2 == 2)                              //设
  649.                             {
  650.                                           if(key_can == 3)              //加
  651.                                                         set_ds1302time(1,&fen7,0x60);                           
  652.                                           if(key_can == 4)              //减               
  653.                                                         set_ds1302time(0,&fen7,0x60);                           
  654.                             }            
  655. /////////////////////                 第8个打铃时间            
  656.                             if(menu_2 == 3)                              //设置打铃分
  657.                             {
  658.                                           if(key_can == 3)              //加            
  659.                                                         set_ds1302time(1,&shi8,0x24);                           
  660.                                           if(key_can == 4)              //减               
  661.                                                         set_ds1302time(0,&shi8,0x24);                           
  662.                             }
  663.                             if(menu_2 == 4)                              //设
  664.                             {
  665.                                           if(key_can == 3)              //加
  666.                                                         set_ds1302time(1,&fen8,0x60);                           
  667.                                           if(key_can == 4)              //减               
  668.                                                         set_ds1302time(0,&fen8,0x60);                           
  669.                             }
  670.                             write_string(1,0," set7 00:00    ");                                         
  671.                             write_string(2,0," set8 00:00      ");            
  672.                             write_sfm2_ds1302(1,6,shi7);                 //显示时
  673.                             write_sfm2_ds1302(1,9,fen7);                 //显示分
  674.                             write_sfm2_ds1302(2,6,shi8);                 //显示时
  675.                             write_sfm2_ds1302(2,9,fen8);                 //显示分
  676.                             switch(menu_2)                 // 光标显示
  677.                             {
  678.                                           case 1:  write_guanbiao(1,6,1);  break;
  679.                                           case 2:  write_guanbiao(1,9,1);  break;
  680.                                           case 3:  write_guanbiao(2,6,1);  break;
  681.                                           case 4:  write_guanbiao(2,9,1);  break;
  682.                             }            
  683.                             write_eeprom();     //保存闹钟时间
  684.               }            
  685. /***************设置9 10打铃时间*********************/
  686.               if(menu_1 == 6)
  687.               {            
  688. /////////////////////                 第9个打铃时间
  689.                             if(menu_2 == 1)                              //设置打铃时
  690.                             {
  691.                                           if(key_can == 3)              //加            
  692.                                                         set_ds1302time(1,&shi9,0x24);                           
  693.                                           if(key_can == 4)              //减               
  694.                                                         set_ds1302time(0,&shi9,0x24);                           
  695.                             }
  696.                             if(menu_2 == 2)                              //设
  697.                             {
  698.                                           if(key_can == 3)              //加
  699.                                                         set_ds1302time(1,&fen9,0x60);                           
  700.                                           if(key_can == 4)              //减               
  701.                                                         set_ds1302time(0,&fen9,0x60);                           
  702.                             }            
  703. /////////////////////                 第10个打铃时间            
  704.                             if(menu_2 == 3)                              //设置打铃分
  705.                             {
  706.                                           if(key_can == 3)              //加            
  707.                                                         set_ds1302time(1,&shi10,0x24);                           
  708.                                           if(key_can == 4)              //减               
  709.                                                         set_ds1302time(0,&shi10,0x24);                           
  710.                             }
  711.                             if(menu_2 == 4)                              //设
  712.                             {
  713.                                           if(key_can == 3)              //加
  714.                                                         set_ds1302time(1,&fen10,0x60);                           
  715.                                           if(key_can == 4)              //减               
  716.                                                         set_ds1302time(0,&fen10,0x60);                           
  717.                             }
  718.                             write_string(1,0," set9 00:00    ");                                         
  719.                             write_string(2,0,"set10 00:00    ");            
  720.                             write_sfm2_ds1302(1,6,shi9);                 //显示时
  721.                             write_sfm2_ds1302(1,9,fen9);                 //显示分
  722.                             write_sfm2_ds1302(2,6,shi10);                 //显示时
  723.                             write_sfm2_ds1302(2,9,fen10);                 //显示分
  724.                             switch(menu_2)                 // 光标显示
  725.                             {
  726.                                           case 1:  write_guanbiao(1,6,1);  break;
  727.                                           case 2:  write_guanbiao(1,9,1);  break;
  728.                                           case 3:  write_guanbiao(2,6,1);  break;
  729.                                           case 4:  write_guanbiao(2,9,1);  break;
  730.                             }            
  731.                             write_eeprom();     //保存闹钟时间
  732.               }                                         

  733. /***************设置9 10打铃时间*********************/
  734.               if(menu_1 == 6)
  735.               {            
  736. /////////////////////                 第9个打铃时间
  737.                             if(menu_2 == 1)                              //设置打铃时
  738.                             {
  739.                                           if(key_can == 3)              //加            
  740.                                                         set_ds1302time(1,&shi9,0x24);                           
  741.                                           if(key_can == 4)              //减               
  742.                                                         set_ds1302time(0,&shi9,0x24);                           
  743. ……………………

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

所有资料51hei提供下载:
单片机自动打铃系统设计毕业论文.doc (845.5 KB, 下载次数: 67)


评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励!

查看全部评分

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

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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