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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 单片机LCD12864万年历如何修改?
返回列表 发新帖
查看: 2409|回复: 4
打印 上一主题 下一主题
收起左侧

单片机LCD12864万年历如何修改?

[复制链接]
跳转到指定楼层
楼主
ID:732107 发表于 2021-5-4 16:20 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
由于本论坛禁止直接求程序,禁止伸手党,所以向大家请教一下大致的实现方法与思路,理清头绪后我自己来写程序去实现,谢谢大家
51单片机做的万年历，要将闹钟报警函数改下，要求添加一个LED灯，使其在闹钟响起前由暗慢慢变亮，当闹钟响时最亮（需要有个变亮的过程）。

8PXYTFJUJZPZM}39)$N5@15.png (19.23 KB, 下载次数: 63)

8PXYTFJUJZPZM}39)$N5@15.png

RWD4$UO]1LGPQRT))1}6W`F.png (47.23 KB, 下载次数: 49)

RWD4$UO]1LGPQRT))1}6W`F.png

7DRVPKWDCR{YL3HNT[}H}ZG.png (24.37 KB, 下载次数: 46)

7DRVPKWDCR{YL3HNT[}H}ZG.png
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:904364 发表于 2021-5-4 16:59 | 只看该作者
写一个呼吸灯的程序就可以实现由暗到亮的过程
回复

使用道具 举报

板凳
ID:390416 发表于 2021-5-4 17:17 | 只看该作者
简单啊 判断秒针时间 把秒针值-10  然后再乘以5 这样就可以从11秒开始 每秒钟增加5个亮度  总共250个亮度
回复

使用道具 举报

地板
ID:732107 发表于 2021-5-4 17:44 | 只看该作者
酱大锤 发表于 2021-5-4 16:59
写一个呼吸灯的程序就可以实现由暗到亮的过程

这是程序您可以帮我看看吗
  1. #include <reg51.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char
  4. #include "value.h"
  5. #include "nongli.h"

  7. uchar n_nian,n_yue,n_ri;
  8. unsigned int CYCLE=800,PWM_LOW=0;
  9. bit flag_200ms = 1;
  10. uchar menu_1;
  11. uchar flag_clock_en;
  12. uchar flag_clock_kai;
  13. uchar flag_c_en;
  14. bit flag_100ms;
  15. sbit beep=P2^7;
  16. sbit LED0=P2^6;
  17. sbit dq=P3^2;
  18. uint temperature ;


  21. void delay_uint(uint z)
  22. {
  23.    while(z--);
  24. }
  25. void Delay(unsigned int t)
  26. {
  27. while(--t);
  28. }

  30. void delay_1ms(uint q)
  31. {
  32.         uint i,j;
  33.         for(i=0;i<q;i++)
  34.                 for(j=0;j<115;j++);
  35. }
  36. uchar dis_lcd[10];

  38. #include "lcd12864bu.h"

  40. void dis_shijian()
  41. {
  42.         write_shu16(3*2,1*8,shi,0);
  43.         write_shuzi(1,3*2,3*8,fuhao[1],0);
  44.         write_shu16(3*2,4*8,fen,0);
  45.         write_shuzi(1,3*2,6*8,fuhao[1],0);
  46.         write_shu16(3*2,7*8,miao,0);


  49.         write_shu16(1*2,6*8,nian,0);
  50.         write_shu16(1*2,10*8,yue,0);
  51.         write_shu16(1*2,14*8,ri,0);

  53.         write_shu16(2*2,4*8,n_yue,0);
  54.         write_shuzi(1,2*2,6*8,fuhao[0],0);
  55.         write_shu16(2*2,7*8,n_ri,0);

  57.         if(week==0)
  58.     {
  59.      write_yhanzi(1,4,7*16,xingqi[0]);
  60.     }
  61.     if(week==1)
  62.     {
  63.      write_yhanzi(1,4,7*16,xingqi[1]);
  64.     }
  65.     if(week==2)
  66.     {
  67.      write_yhanzi(1,4,7*16,xingqi[2]);
  68.     }
  69.     if(week==3)
  70.     {
  71.      write_yhanzi(1,4,7*16,xingqi[3]);
  72.     }
  73.     if(week==4)
  74.     {
  75.      write_yhanzi(1,4,7*16,xingqi[4]);
  76.     }
  77.     if(week==5)
  78.     {
  79.      write_yhanzi(1,4,7*16,xingqi[5]);
  80.     }
  81.     if(week==6)
  82.     {
  83.      write_yhanzi(1,4,7*16,xingqi[6]);
  84.     }
  85.     if(week==7)
  86.     {
  87.      week=0;
  88.      write_yhanzi(1,4,7*16,xingqi[0]);
  89.     }
  90.         write_shu18b20(3*2,10*8,temperature,0);
  91.         write_shuzi(1,3*2,12*8,dian,0);
  92. }


  95. void init_12864_dis()
  96. {
  97.         cs1=1;
  98.         cs2=0;
  99.          write_yhanzi(7,0,16,dzrl);
  100.          write_yhanzi(2,2,0,yangli);
  101.          write_yhanzi(2,4,0,nongli);


  104.         write_shu16(1*2,4*8,0x20,0);
  105.          write_yhanzi(1,2,4*16,qita[0]);
  106.          write_yhanzi(1,2,6*16,qita[1]);
  107.          write_yhanzi(2,4,5*16,qita[6]);
  108.          dis_shijian();
  109.          write_yhanzi(1,6,7*16,wendu_fuhao);

  111. }


  114. void init_18b20()
  115. {
  116.         bit q;
  117.         dq = 1;
  118.         delay_uint(1);
  119.         dq = 0;
  120.         delay_uint(80);
  121.         dq = 1;
  122.         delay_uint(10);
  123.         q = dq;
  124.         delay_uint(20);
  125.         dq = 1;
  126. }


  129. void write_18b20(uchar dat)
  130. {
  131.         uchar i;
  132.         for(i=0;i<8;i++)
  133.         {
  134.                 dq = 0;
  135.                 dq = dat & 0x01;
  136.                 delay_uint(5);
  137.                 dq = 1;
  138.                 dat >>= 1;
  139.         }
  140. }


  143. uchar read_18b20()
  144. {
  145.         uchar i,value;
  146.         for(i=0;i<8;i++)
  147.         {
  148.                 dq = 0;
  149.                 value >>= 1;
  150.                 dq = 1;
  151.                 if(dq == 1)
  152.                         value |= 0x80;
  153.                 delay_uint(5);
  154.         }
  155.         return value;
  156. }


  159. uint read_temp()
  160. {
  161.         uint value;
  162.         uchar low;
  163.         init_18b20();
  164.         write_18b20(0xcc);
  165.         write_18b20(0x44);
  166.         delay_uint(50);

  168.         init_18b20();

  170.         write_18b20(0xcc);
  171.         write_18b20(0xbe);

  173.         EA = 0;
  174.         low = read_18b20();
  175.         value = read_18b20();
  176.         EA = 1;
  177.         value <<= 8;
  178.         value |= low;
  179.         value *= 0.625;
  180.         return value;
  181. }


  184. void dis_shijian_set()
  185. {
  186.         write_shu16(0*2,0*8,0x20,0);
  187.         write_shu16(1*2,2*8,shi,0);
  188.         write_shu16(1*2,6*8,fen,0);
  189.         write_shu16(1*2,10*8,miao,0);
  190.         write_shu16(0*2,2*8,nian,0);
  191.         write_shu16(0*2,6*8,yue,0);
  192.         write_shu16(0*2,10*8,ri,0);
  193.         if(week>=1)
  194.         {
  195.          write_shu16(2*2,10*8,week-1,0);
  196.         }
  197.         if(week<=0)
  198.         {
  199.          week=7;write_shu16(2*2,10*8,week-1,0);
  200.         }
  201.         write_shu16(3*2,8*8,shi1,0);
  202.         write_shu16(3*2,12*8,fen1,0);
  203.         if(flag_clock_kai == 1)
  204.         write_yhanzi_fanbai(1,6,2*16,qita[10],0);
  205.         else
  206.         write_yhanzi_fanbai(1,6,2*16,qita[11],0);
  207. }



  211. void init_12864_set1()
  212. {
  213.         write_yhanzi(1,0,2*16,qita[0]);
  214.          write_yhanzi(1,0,4*16,qita[1]);
  215.          write_yhanzi(1,0,6*16,qita[2]);

  217.         write_yhanzi(1,2,2*16,qita[3]);
  218.          write_yhanzi(1,2,4*16,qita[4]);
  219.          write_yhanzi(1,2,6*16,qita[5]);
  220.         write_yhanzi(2,4,3*16,qita[6]);

  222.         write_yhanzi(2,6,0*16,qita[8]);
  223.         write_yhanzi(1,6,5*16,qita[3]);
  224.          write_yhanzi(1,6,7*16,qita[4]);
  225.         write_yhanzi(2,4,0*16,shezi[0]);

  227.         if(flag_clock_kai == 1)
  228.                 write_yhanzi_fanbai(1,6,2*16,qita[10],0);
  229.         else
  230.                 write_yhanzi_fanbai(1,6,2*16,qita[11],0);
  231.         dis_shijian_set();
  232. }


  235. void ds1302_dis()
  236. {
  237.         uchar miao_1;
  238.         if(menu_1 == 0)
  239.         {
  240.                 read_time();
  241.                 if(miao_1 != miao)
  242.                 {
  243.                         miao_1 = miao;
  244.                         Conversion(0,nian,yue,ri);
  245.                         n_nian = year_moon ;
  246.                         n_yue  = month_moon ;
  247.                         n_ri   = day_moon ;
  248.                         dis_shijian();

  250.                 }
  251.         }
  252. }


  255. uchar key_can;

  257. void key()
  258. {
  259.         static uchar key_new;
  260.         key_can = 20;
  261.         P3 |= 0x78;
  262.         if((P3 & 0x78) != 0x78)
  263.         {
  264.                 delay_1ms(1);
  265.                 if(((P3 & 0x78) != 0x78) && (key_new == 1))
  266.                 {
  267.                         key_new = 0;
  268.                         switch(P3 & 0x78)
  269.                         {
  270.                                 case 0x70:  key_can = 1;  break;
  271.                                 case 0x68:  key_can = 2;  break;
  272.                                 case 0x58:  key_can = 3;  break;
  273.                                 case 0x38:  key_can = 4;  break;
  274.                         }
  275. //                        write_sfm2(1,0,key_can);
  276.                 }
  277.         }
  278.         else
  279.                 key_new = 1;
  280. }


  283. void key_with()
  284. {
  285.         if(key_can == 4)
  286.         {
  287.                 qingling();
  288.                 init_12864_dis();

  290.                 flag_200ms = 1;
  291.                 menu_1 = 0;
  292.         }
  293.         if(key_can == 1)
  294.         {
  295.                 menu_1 ++;
  296.                 flag_200ms = 1;
  297.                 if(menu_1 == 1)
  298.                 {
  299.                         qingling();
  300.                         init_12864_set1();
  301.                 }
  302.                 if(menu_1 > 10)
  303.                         menu_1 = 1;
  304.         }
  305.         if(menu_1 != 0)
  306.         {
  307.                 if(menu_1 == 1)
  308.                 {
  309.                         if(key_can == 2)
  310.                                 set_ds1302time(1,&nian,0x99);
  311.                         if(key_can == 3)
  312.                                 set_ds1302time(0,&nian,0x99);
  313.                 }
  314.                 if(menu_1 == 2)
  315.                 {
  316.                         if(key_can == 2)
  317.                                 set_ds1302time(1,&yue,0x13);
  318.                         if(key_can == 3)
  319.                                 set_ds1302time(0,&yue,0x13);
  320.                 }
  321.                 if(menu_1 == 3)
  322.                 {
  323.                         if(key_can == 2)
  324.                                 set_ds1302time(1,&ri,0x32);
  325.                         if(key_can == 3)
  326.                                 set_ds1302time(0,&ri,0x32);
  327.                 }
  328.                 if(menu_1 == 4)
  329.                 {
  330.                         if(key_can == 4)
  331.                                 set_ds1302time(1,&shi,0x24);
  332.                         if(key_can == 3)
  333.                                 set_ds1302time(0,&shi,0x24);
  334.                 }
  335.                 if(menu_1 == 5)
  336.                 {
  337.                         if(key_can == 2)
  338.                                 set_ds1302time(1,&fen,0x60);
  339.                         if(key_can == 3)
  340.                                 set_ds1302time(0,&fen,0x60);
  341.                 }
  342.                 if(menu_1 == 6)
  343.                 {
  344.                         if(key_can == 2)
  345.                                 set_ds1302time(1,&miao,0x60);
  346.                         if(key_can == 3)
  347.                                 set_ds1302time(0,&miao,0x60);
  348.                 }
  349.                 if(menu_1 == 7)
  350.                 {
  351.                         if(key_can == 2)
  352.                                 set_ds1302time(1,&week,0x8);
  353.                         if(key_can == 3)
  354.                                 set_ds1302time(0,&week,0x8);
  355.                 }
  356.                 if(menu_1 == 8)
  357.                 {
  358.                         if(key_can == 2)
  359.                                 set_ds1302time(1,&shi1,0x24);
  360.                         if(key_can == 3)
  361.                                 set_ds1302time(0,&shi1,0x24);
  362.                         clock1_save();
  363.                 }
  364.                 if(menu_1 == 9)
  365.                 {
  366.                         if(key_can == 2)
  367.                                 set_ds1302time(1,&fen1,0x60);
  368.                         if(key_can == 3)
  369.                                 set_ds1302time(0,&fen1,0x60);
  370.                         clock1_save();
  371.                 }
  372.                 if(menu_1 == 10)
  373.                 {
  374.                         if((key_can == 2) || (key_can == 3))
  375.                                 flag_clock_kai ++;
  376.                         if(flag_clock_kai >= 2)
  377.                                 flag_clock_kai = 0;
  378.                         if(flag_clock_kai == 1)
  379.                                 write_yhanzi_fanbai(1,6,2*16,qita[10],1);
  380.                         else
  381.                                 write_yhanzi_fanbai(1,6,2*16,qita[11],1);
  382.                         clock1_save();
  383.                 }
  384.                  dis_shijian_set();
  385.                 switch(menu_1)
  386.                 {
  387.                         case 1:  write_shu16(0*2,2*8,nian,1);  break;
  388.                         case 2:  write_shu16(0*2,6*8,yue,1);         break;
  389.                         case 3:  write_shu16(0*2,10*8,ri,1);  break;
  390.                         case 4:  write_shu16(1*2,2*8,shi,1);  break;
  391.                         case 5:  write_shu16(1*2,6*8,fen,1);          break;
  392.                         case 6:  write_shu16(1*2,10*8,miao,1);  break;
  393.                         case 7:
  394.                         if(week>0)
  395.                         {
  396.                          write_shu16(2*2,10*8,week-1,1);
  397.                         }
  398.                         if(week<=0)
  399.                         {
  400.                          week=7;
  401.                          write_shu16(2*2,10*8,week-1,1);
  402.                         }
  403.                          break;
  404.                         case 8:  write_shu16(3*2,8*8,shi1,1);  break;
  405.                         case 9:  write_shu16(3*2,12*8,fen1,1); break;
  406.                         case 10: if(flag_clock_kai == 1)
  407.                                         write_yhanzi_fanbai(1,6,2*16,qita[10],1);
  408.                                         else
  409.                                         write_yhanzi_fanbai(1,6,2*16,qita[11],1);
  410.                                          break;
  411.                 }
  412.                 write_time();
  413.         }
  414. }


  417. void menu_dis()
  418. {
  419.         if(menu_1 == 0)
  420.         if(flag_clock_kai == 1)
  421.         {
  422.                 if((fen == fen1) && (shi == shi1) && (miao == 0))
  423.                 {
  424.                         flag_clock_en = 1;
  425.                 }
  426.                 if(flag_clock_en == 1)

  428.                          {
  429.                                  beep=~beep;
  430.                          }
  431.         }
  432. }

  434. //void deng
  435. /













  449. /


  452. void time0_init()
  453. {
  454.         EA  = 1;
  455.         TMOD = 0X11;
  456.         ET0 = 1;
  457.         TR0 = 1;
  458. }

  460. void main()
  461. {
  462.                 beep = 0;
  463.                 delay_1ms(150);
  464.                 P0 = P1 = P2 = P3 = 0xff;
  465.                 init_ds1302();
  466.                 init_lcd();
  467.                 Clr_Scr();
  468.                 time0_init();
  469.                 init_12864_dis();
  470.         while(1)
  471.     {
  472.                 key();
  473.                 if(key_can < 10)
  474.                 {
  475.                         if(flag_clock_en == 0)
  476.                                 key_with();
  477.                         else
  478.                         {
  479.                                 beep = 1;
  480.                                 flag_clock_en = 0;
  481.                         }
  482.                 }
  483.                 if(flag_100ms == 1)
  484.                 {
  485.                         menu_dis();
  486.                         flag_100ms = 0;
  487.                 }
  488.                  if(flag_200ms == 1)
  489.                 {
  490.                         flag_200ms = 0;
  491.                         temperature = read_temp();
  492.                         ds1302_dis();
  493.                 }

  495.         }
  496. }


  499. void time0_int() interrupt 1
  500. {
  501.         static uchar value;
  502.         TH0 = 0x3c;
  503.         TL0 = 0xb0;
  504.         value ++;
  505.         if(value % 2 == 0)
  506.         {
  507.                 flag_100ms = 1;
  508.         }
  509.         if(value % 20 == 0)
  510.         {
  511.                 flag_200ms = 1;
  512.         }
  513. }
复制代码


回复

使用道具 举报

5#
ID:230742 发表于 2021-5-4 20:57 | 只看该作者
单独写一个呼吸灯的函数
呼吸灯（）
然后在闹钟的BEEP前先调用这个函数，灯亮了，闹钟也响了。
响完关闭灯光。
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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