找回密码
 立即注册

QQ登录

只需一步,快速开始

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

这是一个基于单片机制作万年历相关的论文 含原理图 代码等,希望和大家一起分享

[复制链接]
跳转到指定楼层
楼主
论文下载:
基于51单片机的电子万年历毕业论文设计.doc (1.49 MB, 下载次数: 11)

电路原理图如下:

  1. 设计主程序:
  2. /*
  3. * 万年历
  4. */


  5. #include "main.h"
  6. #include "LCD.h"
  7. #include "DS1302.h"
  8. #include "word.h"
  9. #include "lunar_calendar.h"
  10. #include "buzz.h"


  11. TIME time, tmp_time;
  12. ALARM alarm;
  13. bit Alarm_flag=0;
  14. bit Clock_flag=0;
  15. bit flag=0;

  16. sbit DQ=P2^6;   //DS18B20 pin

  17. //-----------------18B20-----------------------
  18. unsigned char L_18B20,H_18B20,zhengshu,shangwen,xiawen;
  19. unsigned int fg=0,xiaoshu_a;
  20. //-----------------18B20----------------------
  21. //-------------音乐-----------------------------
  22. uint8 code SONG_TONE[]=
  23. {
  24.          212,212,190,212,159,169,212,212,190,212,142,159,212,212,106,126,129,169,190,119,119,126,159,142,159,0
  25. };
  26. uint8 code SONG_LONG[]=
  27. {
  28.          9,3,12,12,12,24,9,3,12,12,12,24,9,3,12,12,12,12,12,9,3,12,12,12,24,0
  29. };
  30. //------------------------------------------------------------

  31. void delay(uint16 n)
  32. {
  33.         while (n--);
  34. }
  35. //************************************************************************/
  36. // 函数: LCD_Delay()
  37. // 描述: 延时t ms函数
  38. // 参数: t
  39. // 返回: 无
  40. // 备注: 11.0592MHZ       t=1延时时间约1ms
  41. // 版本:  2011/01/01      First version
  42. //************************************************************************/
  43. void Delay_nms(unsigned int t)
  44. {
  45.         unsigned int i,j;
  46.         for(i=0;i<t;i++)
  47.         for(j=0;j<113;j++)
  48.         ;
  49. }
  50. /////////////////////////////////////////////////
  51. //-----------播放音乐----------------------------
  52. void PlayMusic()
  53. {
  54.          uint16 i =0,j,k;
  55.         while(SONG_LONG[i]!=0||SONG_TONE[i]!=0)
  56.         {
  57.                  for(j=0;j<SONG_LONG[i]*20;j++)
  58.                 {
  59.                          BEEP = ~BEEP;
  60.                         for(k=0;k<SONG_TONE[i]/3;k++);
  61.                 }
  62.                 Delay_nms(10);
  63.                 i++;
  64.         }
  65.         BEEP =1;//关闭蜂鸣器
  66. }
  67. /////////////////////////////////////////////////
  68. /*------DS18B20------*/
  69. void delay_18B20(unsigned int i)
  70. {
  71.         while(i--);
  72. }
  73. /*DS18B20的复位脉冲 主机通过拉低单总线至少480us以产生复位脉冲
  74.   然后主机释放单总线并进入接收模式 此时单总线电平被拉高
  75.   DS18B20检测到上升沿后 延时15~60us,拉低总线60~240us产生应答脉冲  */                                                
  76. void Init_DS18B20(void)
  77. {
  78.          unsigned char x=0;
  79.          DQ = 1;          //DQ复位
  80.          delay_18B20(8);  //稍做延时
  81.          DQ = 0;          //单片机将DQ拉低
  82.          delay_18B20(80); //精确延时 大于 480us
  83.          DQ = 1;          //拉高总线
  84.          delay_18B20(14);
  85.          x=DQ;            //稍做延时后 如果x=0则初始化成功 x=1则初始化失败
  86.          delay_18B20(20);
  87. }

  88. /*写时隙 主机在写1时隙向DS18B20写入1,在写0时隙向DS18B20写入0
  89.   所有写时隙至少需要60us,且在两次写时隙之间至少需要1us的恢复时间
  90.   两种写时隙均以主机拉低总线开始
  91.   产生写1时隙:主机拉低总线后,必须在15us内释放总线,由上拉电阻拉回至高电平
  92.   产生写0时隙:主机拉低总线后,必须整个时隙保持低电平 */
  93. void WriteOneChar(unsigned char dat)
  94. {
  95.          unsigned char i=0;
  96.          for (i=8; i>0; i--)
  97.          {
  98.                   DQ = 0;
  99.                  DQ = dat&0x01;
  100.             delay_18B20(5);
  101.                  DQ = 1;
  102.             dat>>=1;
  103. }
  104. }
  105.   
  106. /*所有读时隙至少60us 且两次独立的读时隙之间至少需要1us的恢复时间
  107.   每次读时隙由主机发起,拉低总线至少1us。
  108.   若传1,则保持总线高电平;若发送0,则拉低总线
  109.   传0时DS18B20在该时隙结束时释放总线,再拉回高电平状态,主机必须在读时隙开始后的15us内释放总线,并保持采样总线状态 */
  110. unsigned char ReadOneChar(void)
  111. {
  112.         unsigned char i=0;
  113.         unsigned char dat = 0;
  114.         for (i=8;i>0;i--)
  115.          {
  116.                   DQ = 0; // 给脉冲信号
  117.                   dat>>=1;
  118.                   DQ = 1; // 给脉冲信号
  119.                   if(DQ)
  120.                   dat|=0x80;
  121.                   delay_18B20(4);
  122.          }
  123.          return(dat);
  124. }
  125.                  

  126. void read_18B20(void)
  127. {

  128.         Init_DS18B20();
  129.         WriteOneChar(0xCC);            // 跳过读序号列号的操作
  130.         WriteOneChar(0x44);         // 启动温度转换

  131.         delay_18B20(100);       // this message is wery important

  132.         Init_DS18B20();
  133.         WriteOneChar(0xCC);         //跳过读序号列号的操作
  134.         WriteOneChar(0xBE);         //读取温度寄存器等(共可读9个寄存器) 前两个就是温度

  135.         delay_18B20(100);

  136.         L_18B20=ReadOneChar();        //读取低八位数据
  137.         H_18B20=ReadOneChar();        //读取高八位数据

  138.         zhengshu=L_18B20/16+H_18B20*16; //整数部分
  139.         xiaoshu_a=(L_18B20&0x0f)*10/16; //小数第一位
  140. }
  141. //------------------DS18B20---------------------
  142. /////////////////////////////////////////////////
  143. /*
  144. * 按键扫描
  145. */
  146. int8 scan_key(void)
  147. {
  148.         int8 val=-1;

  149.         if (KeyIn1 == 0)
  150.         {
  151.                 val = 1;
  152.                 while (KeyIn1 == 0);
  153.         }
  154.         else if (KeyIn2 == 0)
  155.         {
  156.                 val = 2;
  157.                 while (KeyIn2 == 0);
  158.         }
  159.         else if (KeyIn3 == 0)
  160.         {
  161.                 val = 3;
  162.                 while (KeyIn3 == 0);
  163.         }

  164.         //if (val > 0)
  165.                 //buzzer_sound();

  166.         return val;
  167. }

  168. /*
  169. * 主界面框架
  170. */
  171. void main_frame(void)
  172. {
  173.         play32(80, 2, 10);
  174.         play32(32, 2, 10);
  175.         play8(16, 0, S_xie);
  176.         play8(40, 0, S_xie);
  177. //        play8(96, 0, RH);
  178. //        play8(120, 0, S_percent);
  179.         play8(120, 6, S_du);
  180. }

  181. /*
  182. * 主界面
  183. */
  184. void main_show(bit refresh)
  185. {
  186.     uint8  lunar[2];
  187.         if (refresh)
  188.                 read_time((uint8 *)&time);

  189.         // 时间
  190.         if (refresh || (time.sec != tmp_time.sec)) // 秒更新
  191.         {
  192.                 tmp_time.sec = time.sec;
  193.                 // 温湿度
  194.              play8_num(104, 6,zhengshu);   //温度显示
  195.                 play32_num(96, 2, time.sec);
  196.         }

  197.         if (refresh)
  198.                 main_frame();

  199.         if (refresh || (time.min != tmp_time.min)) // 分更新
  200.         {
  201.                 if (!refresh)
  202.                         flag = 0;
  203.                 tmp_time.min = time.min;
  204.                 play32_num(48, 2, time.min);
  205.         }

  206.         if (refresh || (time.hour != tmp_time.hour)) // 时更新
  207.         {
  208.                 if ((!refresh)&&(Clock_flag))
  209.                         alarm_sound();
  210.                 tmp_time.hour = time.hour;
  211.                 play32_num(0, 2, time.hour);
  212.         }

  213.         if (refresh || (time.day != tmp_time.day)) // 日更新
  214.         {
  215.                 tmp_time.day = time.day;
  216.                 play8_num(48, 0, time.day);
  217.                 // 农历        
  218.                 turn_lunar_calendar(&time, lunar);
  219.                 play_lunar_calendar(0, 6, lunar[0], lunar[1]);
  220.         }

  221.         if (refresh || (time.week != tmp_time.week)) // 周更新
  222.         {
  223.                 tmp_time.week = time.week;
  224.                 play_week(68, 0, time.week);
  225.         }

  226.         if (refresh || (time.mon != tmp_time.mon)) // 月更新
  227.         {
  228.                 tmp_time.mon = time.mon;
  229.                 play8_num(24, 0, time.mon);
  230.                 // 农历        
  231.                 turn_lunar_calendar(&time, lunar);
  232.                 play_lunar_calendar(0, 6, lunar[0], lunar[1]);
  233.         }

  234.         if (refresh || (time.year != tmp_time.year)) // 年更新
  235.         {
  236.                 tmp_time.year = time.year;
  237.                 play8_num(0, 0, time.year);
  238.                 // 农历        
  239.                 turn_lunar_calendar(&time, lunar);
  240.                 play_lunar_calendar(0, 6, lunar[0], lunar[1]);
  241.         }
  242.         
  243. }

  244. /*
  245. * 主机界面设置
  246. */
  247. void main_set(void)
  248. {
  249.         int8 key_val, state=1;

  250.         play32_num(96, 2|0x80, time.sec);
  251.                         
  252.         while (1)
  253.         {
  254.                 key_val = scan_key();
  255.                
  256.                 if (key_val == 1) // 设置
  257.                 {
  258.                         if (state >= 7)
  259.                                 state = 0;
  260.                         else
  261.                                 state++;
  262.                         set_time((uint8 *)&time);
  263.                         main_show(1);
  264.                         switch (state)
  265.                         {
  266.                                 case 0:        set_time((uint8 *)&time); break;
  267.                                 case 1:        play32_num(96, 2|0x80, time.sec); break;
  268.                                 case 2:        play32_num(48, 2|0x80, time.min); break;
  269.                                 case 3:        play32_num(0, 2|0x80, time.hour); break;
  270.                                 case 4:        play_week(68, 0|0x80, time.week); break;
  271.                                 case 5:        play8_num(48, 0|0x80, time.day); break;
  272.                                 case 6:        play8_num(24, 0|0x80, time.mon); break;
  273.                                 case 7:        play8_num(0, 0|0x80, time.year); break;
  274.                                 default: break;
  275.                         }
  276.                 }
  277.                 else if (key_val > 1)
  278.                 {
  279.                         if (state == 1)
  280.                         {
  281.                                 if (key_val == 3)
  282.                                         time.sec++;
  283.                                 else
  284.                                         time.sec--;
  285.                                 if (time.sec >= 60)
  286.                                         time.sec = 0;
  287.                                 else if (time.sec < 0)
  288.                                         time.sec = 59;
  289.                                 play32_num(96, 2|0x80, time.sec);
  290.                         }
  291.                         else if (state == 2)
  292.                         {
  293.                                 if (key_val == 3)
  294.                                         time.min++;
  295.                                 else
  296.                                         time.min--;
  297.                                 if (time.min >= 60)
  298.                                         time.min = 0;
  299.                                 else if (time.min < 0)
  300.                                         time.min = 59;
  301.                                 play32_num(48, 2|0x80, time.min);
  302.                         }
  303.                         else if (state == 3)
  304.                         {
  305.                                 if (key_val == 3)
  306.                                         time.hour++;
  307.                                 else
  308.                                         time.hour--;
  309.                                 if (time.hour >= 24)
  310.                                         time.hour = 0;
  311.                                 else if (time.hour < 0)
  312.                                         time.hour = 23;
  313.                                 play32_num(0, 2|0x80, time.hour);
  314.                         }
  315.                         else if (state == 4)
  316.                         {
  317.                                 if (key_val == 3)
  318.                                         time.week++;
  319.                                 else
  320.                                         time.week--;
  321.                                 if (time.week >= 8)
  322.                                         time.week = 1;
  323.                                 else if (time.week < 1)
  324.                                         time.week = 7;
  325.                                 play_week(68, 0|0x80, time.week);
  326.                         }
  327.                         else if (state == 5)
  328.                         {
  329.                                 if (key_val == 3)
  330.                                         time.day++;
  331.                                 else
  332.                                         time.day--;
  333.                                 if (time.day >= 32)
  334.                                         time.day = 1;
  335.                                 else if (time.day < 1)
  336.                                         time.day = 31;
  337.                                 play8_num(48, 0|0x80, time.day);
  338.                         }
  339.                         else if (state == 6)
  340.                         {
  341.                                 if (key_val == 3)
  342.                                         time.mon++;
  343.                                 else
  344.                                         time.mon--;
  345.                                 if (time.mon >= 13)
  346.                                         time.mon = 1;
  347.                                 else if (time.mon < 1)
  348.                                         time.mon = 12;
  349.                                 play8_num(24, 0|0x80, time.mon);
  350.                         }
  351.                         else if (state == 7)
  352.                         {
  353.                                 if (key_val == 3)
  354.                                         time.year++;
  355.                                 else
  356.                                         time.year--;
  357.                                 if (time.year >= 100)
  358.                                         time.year = 0;
  359.                                 else if (time.year < 0)
  360.                                         time.year = 99;
  361.                                 play8_num(0, 0|0x80, time.year);
  362.                         }
  363.                         else
  364.                         {
  365.                                 break;
  366.                         }
  367.                 }
  368.                 if (state == 0)
  369.                         break;
  370.         }
  371. }

  372. /*
  373. * 闹钟界面显示
  374. */
  375. void alarm_show(void)
  376. {
  377.         int8 key_val, state=1;
  378.         uint32 t=0;

  379.         play16(0, 0, nao);
  380.         play16(16, 0, zhong);
  381.         play16(32, 0, maohao);
  382.         if (Alarm_flag)
  383.                 play16(48, 0, kai);
  384.         else
  385.                 play16(48, 0, guan);

  386.         play32_num(32, 2, alarm.hour);
  387.         play32(64, 2, 10);
  388.         play32_num(80, 2, alarm.min);
  389.         
  390.         play16(0, 6, zheng);
  391.         play16(16, 6, dian);
  392.         play16(32, 6, bao);
  393.         play16(48, 6, shi);
  394.         play16(64, 6, maohao);
  395.         if (Clock_flag)
  396.                 play16(80, 6, kai);
  397.         else
  398.                 play16(80, 6, guan);
  399.         
  400.         for (t=0; t<30000; t++)
  401.         {
  402.                 key_val = scan_key();
  403.                 if (key_val > 1)
  404.                         break;
  405.                 else if (key_val == 1)
  406.                 {
  407.                         if (Alarm_flag)
  408.                                 play16(48, 0|0x80, kai);
  409.                         else
  410.                                 play16(48, 0|0x80, guan);
  411.                         
  412.                         while (1)
  413.                         {
  414.                                 key_val = scan_key();
  415.                                 
  416.                                 if (key_val == 1) // 完成设置
  417.                                 {
  418.                                         if (state >= 4)
  419.                                                 state = 0;
  420.                                         else
  421.                                                 state++;
  422.                                         if (Alarm_flag)
  423.                                                 play16(48, 0, kai);
  424.                                         else
  425.                                                 play16(48, 0, guan);
  426.                                         play32_num(32, 2, alarm.hour);
  427.                                         play32_num(80, 2, alarm.min);
  428.                                         if (Clock_flag)
  429.                                                 play16(80, 6, kai);
  430.                                         else
  431.                                                 play16(80, 6, guan);

  432.                                         switch (state)
  433.                                         {
  434.                                                 case 1:         
  435.                                                         if (Alarm_flag)
  436.                                                                 play16(48, 0|0x80, kai);
  437.                                                         else
  438.                                                                 play16(48, 0|0x80, guan);
  439.                                                         break;
  440.                                                 case 2:
  441.                                                         play32_num(80, 2|0x80, alarm.min);
  442.                                                         break;
  443.                                                 case 3:
  444.                                                         play32_num(32, 2|0x80, alarm.hour);
  445.                                                         break;
  446.                                                 case 4:
  447.                                                         if (Clock_flag)
  448.                                                                 play16(80, 6|0x80, kai);
  449.                                                         else
  450.                                                                 play16(80, 6|0x80, guan);
  451.                                                         break;
  452.                                                 default: break;
  453.                                         }
  454.                                 }
  455.                                 else if (key_val > 1)
  456.                                 {
  457.                                         if (state == 1)
  458.                                         {
  459.                                                 Alarm_flag = ~Alarm_flag;
  460.                                                 if (Alarm_flag)
  461.                                                         play16(48, 0|0x80, kai);
  462.                                                 else
  463.                                                         play16(48, 0|0x80, guan);
  464.                                         }
  465.                                         else if (state == 2)
  466.                                         {
  467.                                                 if (key_val == 3)
  468.                                                         alarm.min++;
  469.                                                 else
  470.                                                         alarm.min--;
  471.                                                 if (alarm.min >= 60)
  472.                                                         alarm.min = 0;
  473.                                                 else if (alarm.min < 0)
  474.                                                         alarm.min = 59;
  475.                                                 play32_num(80, 2|0x80, alarm.min);
  476.                                         }
  477.                                         else if (state == 3)
  478.                                         {
  479.                                                 if (key_val == 3)
  480.                                                         alarm.hour++;
  481.                                                 else
  482.                                                         alarm.hour--;
  483.                                                 if (alarm.hour >= 24)
  484.                                                         alarm.hour = 0;
  485.                                                 else if (alarm.hour < 0)
  486.                                                         alarm.hour = 23;
  487.                                                 play32_num(32, 2|0x80, alarm.hour);
  488.                                         }
  489.                                         else if (state == 4)
  490.                                         {
  491.                                                 Clock_flag = ~Clock_flag;
  492.                                                 if (Clock_flag)
  493.                                                         play16(80, 6|0x80, kai);
  494.                                                 else
  495.                                                         play16(80, 6|0x80, guan);
  496.                                         }
  497.                                         else
  498.                                         {
  499.                                                 break;
  500.                                         }
  501.                                 }
  502.                                 if (state == 0)
  503.                                 break;
  504.                         }
  505.                         if (state == 0)
  506.                                 break;
  507.                 }

  508.         }
  509. }


  510. main()
  511. {
  512.         uint8 key_val;
  513.     read_18B20();    //读温度
  514.     Delay_nms(1000);//延时1S,等待18B20工作正常


  515.         LCD_init();           //初始化液晶
  516.         clear12864();         //清屏幕
  517.         main_frame();         //显示主界面框架
  518.         main_show(1);         //刷新1次

  519.     read_18B20();                                    //读温度
  520.         play8_num(104, 6,zhengshu);   //显示温度

  521.         while(1)
  522.         {
  523.                 key_val = scan_key();
  524.                 if (key_val == 1)         //K1?
  525.                 {
  526.                         main_set();
  527.                 }
  528.                 else if (key_val == 2)    //K2?
  529.                 {
  530.                         clear12864();         //清屏幕
  531.                         alarm_show();
  532.                         clear12864();              //清屏幕
  533.                         main_show(1);
  534.                 }
  535.                 else if (key_val == 3)    //K3?
  536.                 {
  537.                         clear12864();         //清屏幕
  538.                         alarm_show();
  539.                         clear12864();         //清屏幕
  540.                         main_show(1);
  541.                 }
  542.                 else
  543.                 {
  544.                         read_time((uint8 *)&time);
  545.                         main_show(0);
  546.                         if((time.sec%2)==0){read_18B20();}  //每隔2S采集一次

  547.                 }
  548.                
  549.                 // 闹钟
  550.                 if (Alarm_flag)
  551.                 {
  552.                         if ((flag == 0) && (alarm.hour == time.hour) && (alarm.min == time.min))
  553.                         {
  554.                                 flag = 1;
  555.                                 clear12864();     //清屏幕
  556.                                 alarm_show();     //闹钟
  557.                             PlayMusic();      //播放音乐
  558.                                 PlayMusic();      //播放音乐
  559.                                 clear12864();     //清屏幕  
  560.                                 main_show(1);     //
  561.                         }
  562.                 }
  563.         }
  564. }
复制代码

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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