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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 24小时必答区 › 自己写的lcd1602时钟仿真，有闹钟功能，哪位高手能增加 ...
返回列表 发新帖
查看: 4119|回复: 8
打印 上一主题 下一主题
收起左侧

自己写的lcd1602时钟仿真，有闹钟功能，哪位高手能增加个长按暂停键唤出闹钟界面功能

[复制链接]
跳转到指定楼层
楼主
ID:84598 发表于 2015-7-21 12:40 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
如果能把长按暂停键唤出闹钟界面就好了，但是不成功，各位大神看看怎么改

无标题.png (278.45 KB, 下载次数: 117)

效果图

效果图

无标题1.png (278.11 KB, 下载次数: 113)

效果图

效果图

1602时钟.rar

1.33 MB, 下载次数: 96

评分

参与人数 1黑币 +30 收起 理由
admin + 30 共享资料的积分奖励！

查看全部评分

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

使用道具 举报

沙发
ID:84598 发表于 2015-7-21 12:41 | 只看该作者
仿真及程序都在压缩包里
  1. #include<reg52.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char
  4. sbit RS=P1^3;
  5. sbit R_W=P1^4;
  6. sbit E=P1^5;
  7. sbit wx=P2^6;
  8. sbit dx=P2^7;
  9. sbit O=P3^4;
  10. sbit L=P3^5;
  11. sbit R=P3^6;
  12. sbit S=P3^7;
  13. sbit beep=P2^2;
  14. uint n=2015;
  15. uchar num,w,s=6,f=0,m=0,q,p,y=5,d=5,cs,cf,t=0x58;
  16. char r=0;
  17. bit a;
  18. uchar code table[]={0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39};
  19. uchar code table1[]={"Mon"};
  20. uchar code table2[]={"Tue"};
  21. uchar code table3[]={"Wed"};
  22. uchar code table4[]={"Thu"};
  23. uchar code table5[]={"Fri"};
  24. uchar code table6[]={"Sat"};
  25. uchar code table7[]={"Sun"};
  26. void lcdshow();
  27. void delay(uchar s)
  28. {
  29.         uchar j,k;
  30.         for(j=s;j>0;j--)
  31.                 for(k=114;k>0;k--);
  32. }
  33. void R_busy()
  34. {
  35.         P0=0x00;
  36.         RS=0;
  37.         R_W=1;
  38.         E=1;
  39.         while(P0&0x80);
  40.         E=0;
  41. }
  42. void W_cmd(uchar com)
  43. {
  44.         R_busy();
  45.         RS=0;
  46.         R_W=0;
  47.         P0=com;
  48.         delay(2);
  49.         E=1;
  50.         delay(2);
  51.         E=0;
  52. }
  53. void W_data(uchar date)
  54. {
  55.         R_busy();
  56.         RS=1;
  57.         R_W=0;
  58.         P0=date;
  59.         delay(2);
  60.         E=1;
  61.         delay(2);
  62.         E=0;
  63. }
  64. void init()
  65. {
  66.         wx=0;
  67.         dx=0;
  68.         E=0;
  69.         EA=1;
  70.         ET0=1;
  71.         TR0=1;
  72.         TMOD=0x01;
  73.         TH0=(65536-46080)/256;
  74.         TL0=(65536-46080)%256;
  75.         W_cmd(0x38);
  76.         W_cmd(0x0c);
  77.         W_cmd(0x06);
  78.         W_cmd(0x01);
  79. }
  80. void week()
  81. {
  82.         uchar m;
  83.         w=((n/100)/4)-2*(n/100)+(n%100)+((n%100)/4)+((13*(y+1))/5)+d-1;
  84.         W_cmd(0x80+0x0c);
  85.         switch(w%7)
  86.         {
  87.                 case 0:
  88.                 for(m=0;m<3;m++)
  89.                 {
  90.                         W_data(table7[m]);
  91.                 }
  92.                 break;

  94.                 case 1:
  95.                 for(m=0;m<3;m++)
  96.                 {
  97.                         W_data(table1[m]);
  98.                 }
  99.                 break;

  101.                 case 2:
  102.                 for(m=0;m<3;m++)
  103.                 {
  104.                         W_data(table2[m]);
  105.                 }
  106.                 break;

  108.                 case 3:
  109.                 for(m=0;m<3;m++)
  110.                 {
  111.                         W_data(table3[m]);
  112.                 }
  113.                 break;

  115.                 case 4:
  116.                 for(m=0;m<3;m++)
  117.                 {
  118.                         W_data(table4[m]);
  119.                 }
  120.                 break;

  122.                 case 5:
  123.                 for(m=0;m<3;m++)
  124.                 {
  125.                         W_data(table5[m]);
  126.                 }
  127.                 break;

  129.                 case 6:
  130.                 for(m=0;m<3;m++)
  131.                 {
  132.                         W_data(table6[m]);
  133.                 }
  134.                 break;

  136.                 default:
  137.                 break;
  138.         }
  139. }
  140. void control_move()
  141. {
  142.         switch(r)
  143.         {
  144.                 case 0:
  145.                 W_cmd(0x80+0x01);
  146.                 break;

  148.                 case 1:
  149.                 W_cmd(0x80+0x02);
  150.                 break;

  152.                 case 2:
  153.                 W_cmd(0x80+0x03);
  154.                 break;

  156.                 case 3:
  157.                 W_cmd(0x80+0x04);
  158.                 break;

  160.                 case 4:
  161.                 W_cmd(0x80+0x06);
  162.                 break;

  164.                 case 5:
  165.                 W_cmd(0x80+0x07);
  166.                 break;

  168.                 case 6:
  169.                 W_cmd(0x80+0x09);
  170.                 break;

  172.                 case 7:
  173.                 W_cmd(0x80+0x0a);
  174.                 break;

  176.                 case 8:
  177.                 W_cmd(0x80+0x44);
  178.                 break;

  180.                 case 9:
  181.                 W_cmd(0x80+0x45);
  182.                 break;

  184.                 case 10:
  185.                 W_cmd(0x80+0x47);
  186.                 break;

  188.                 case 11:
  189.                 W_cmd(0x80+0x48);
  190.                 break;

  192.                 case 12:
  193.                 W_cmd(0x80+0x4a);
  194.                 break;

  196.                 case 13:
  197.                 W_cmd(0x80+0x4b);
  198.                 break;

  200.                 case 14:
  201.                 W_cmd(0x80+0x4e);
  202.                 break;

  204.                 case 16:
  205.                 W_cmd(0x80+0x11);
  206.                 W_data(table[cs/10]);
  207.                 W_cmd(0x80+0x11);
  208.                 break;

  210.                 case 17:
  211.                 W_cmd(0x80+0x12);
  212.                 W_data(table[cs%10]);
  213.                 W_cmd(0x80+0x12);
  214.                 break;

  216.                 case 18:
  217.                 W_cmd(0x80+0x14);
  218.                 W_data(table[cf/10]);
  219.                 W_cmd(0x80+0x14);
  220.                 break;

  222.                 case 19:
  223.                 W_cmd(0x80+0x15);
  224.                 W_data(table[cf%10]);
  225.                 W_cmd(0x80+0x15);
  226.                 break;

  228.                 case 20:
  229.                 W_cmd(0x80+0x17);
  230.                 break;

  232.                 case 21:
  233.                 W_cmd(0x80+0x19);
  234.                 break;

  236.                 default:
  237.                 if(r>20)
  238.                         W_cmd(0x80+0x11);
  239.                 if(r<16)
  240.                         W_cmd(0x80+0x01);
  241.                 break;
  242.         }
  243. }
  244. void leap()
  245. {
  246.         switch(y)
  247.         {
  248.                 case 2:
  249.                 if(n%4==0&&n%100!=0||n%400==0)
  250.                 {
  251.                         if(d>29)
  252.                         d=1;
  253.                         y++;
  254.                 }
  255.                 else
  256.                 {
  257.                         if(d>28)
  258.                         d=1;
  259.                         y++;
  260.                 }
  261.                 break;

  263.                 case 4:
  264.                 if(d>30)
  265.                 {
  266.                         d=1;
  267.                         y++;
  268.                 }
  269.                 break;

  271.                 case 6:
  272.                 if(d>30)
  273.                 {
  274.                         d=1;
  275.                         y++;
  276.                 }
  277.                 break;

  279.                 case 9:
  280.                 if(d>30)
  281.                 {
  282.                         d=1;
  283.                         y++;
  284.                 }
  285.                 break;

  287.                 case 11:
  288.                 if(d>30)
  289.                 {
  290.                         d=1;
  291.                         y++;
  292.                 }
  293.                 break;

  295.                 default:
  296.                 if(d>31)
  297.                 {
  298.                         d=1;
  299.                         y++;
  300.                 }
  301.                 break;
  302.         }
  303. }
  304. void lcdshow()
  305. {
  306.         W_cmd(0x80);
  307.         W_data(0x20);
  308.         W_data(table[n/1000]);
  309.         W_data(table[(n/100)%10]);
  310.         W_data(table[(n/10)%10]);
  311.         W_data(table[n%10]);
  312.         W_data(0x2f);
  313.         W_data(table[y/10]);
  314.         W_data(table[y%10]);
  315.         W_data(0x2f);
  316.         W_data(table[d/10]);
  317.         W_data(table[d%10]);
  318.         W_cmd(0x80+0x44);
  319.         W_data(table[s/10]);
  320.         W_data(table[s%10]);
  321.         W_data(0x3a);
  322.         W_data(table[f/10]);
  323.         W_data(table[f%10]);
  324.         W_data(0x3a);
  325.         W_data(table[m/10]);
  326.         W_data(table[m%10]);   
  327.         W_cmd(0x80+0x11);
  328.         W_data(table[cs/10]);
  329.         W_data(table[cs%10]);
  330.         W_data(0x3a);
  331.         W_data(table[cf/10]);
  332.         W_data(table[cf%10]);
  333.         W_cmd(0x80+0x17);
  334.         W_data(t);
  335.         W_cmd(0x80+0x19);
  336.         W_data(0x3c);
  337.         week();
  338.         beep=1;
  339. }

  341. void control_set()
  342. {
  343.         uchar c;       
  344.         switch(r)
  345.         {
  346.                 case 0:
  347.                 n=n+1000;
  348.                 if(n>9999)
  349.                         n=0;
  350.                 lcdshow();
  351.                 W_cmd(0x80+0x01);
  352.                 break;

  354.                 case 1:
  355.                 n=n+100;
  356.                 if(n>9999)
  357.                         n=0;
  358.                 lcdshow();
  359.                 W_cmd(0x80+0x02);
  360.                 break;

  362.                 case 2:
  363.                 n=n+10;
  364.                 if(n>9999)
  365.                         n=0;
  366.                 lcdshow();
  367.                 W_cmd(0x80+0x03);
  368.                 break;

  370.                 case 3:
  371.                 n=n+1;
  372.                 if(n>9999)
  373.                         n=0;
  374.                 lcdshow();
  375.                 W_cmd(0x80+0x04);
  376.                 break;

  378.                 case 4:
  379.                 y=y+10;
  380.                 if(y>12)
  381.                 {
  382.                         y=1;
  383.                 }
  384.                 lcdshow();
  385.                 W_cmd(0x80+0x06);
  386.                 break;

  388.                 case 5:
  389.                 y=y+1;
  390.                 if(y>12)
  391.                 {       
  392.                         y=1;
  393.                 }
  394.                 lcdshow();
  395.                 W_cmd(0x80+0x07);
  396.                 break;

  398.                 case 6:
  399.                 d=d+10;
  400.                 leap();
  401.                 lcdshow();
  402.                 W_cmd(0x80+0x09);
  403.                 break;

  405.                 case 7:
  406.                 d=d+1;
  407.                 leap();
  408.                 lcdshow();
  409.                 W_cmd(0x80+0x0a);
  410.                 break;

  412.                 case 8:
  413.                 s=s+10;
  414.                 if(s>23)       
  415.                         s=0;
  416.                 lcdshow();
  417.                 W_cmd(0x80+0x44);
  418.                 break;

  420.                 case 9:
  421.                 s=s+1;
  422.                 if(s>23)
  423.                         s=0;
  424.                 lcdshow();
  425.                 W_cmd(0x80+0x45);
  426.                 break;

  428.                 case 10:
  429.                 f=f+10;
  430.                 if(f>59)
  431.                         f=0;
  432.                 lcdshow();
  433.                 W_cmd(0x80+0x47);
  434.                 break;

  436.                 case 11:
  437.                 f=f+1;
  438.                 if(f>59)
  439.                         f=0;
  440.                 lcdshow();
  441.                 W_cmd(0x80+0x48);
  442.                 break;

  444.                 case 12:
  445.                 m=m+10;
  446.                 if(m>59)
  447.                         m=0;
  448.                 lcdshow();
  449.                 W_cmd(0x80+0x4a);
  450.                 break;

  452.                 case 13:
  453.                 m=m+1;
  454.                 if(m>59)
  455.                         m=0;
  456.                 lcdshow();
  457.                 W_cmd(0x80+0x4b);
  458.                 break;

  460.                 case 14:
  461.                 for(c=0;c<16;c++)
  462.                 {
  463.                         W_cmd(0x18);
  464.                         delay(150);
  465.                 }
  466.                 r=16;
  467.                 W_cmd(0x80+0x11);
  468.                 break;

  470.                 case 16:
  471.                 cs=cs+10;
  472.                 if(cs>23)
  473.                         cs=0;
  474.                 W_cmd(0x80+0x11);
  475.                 W_data(table[cs/10]);
  476.                 W_data(table[cs%10]);
  477.                 W_cmd(0x80+0x11);
  478.                 break;

  480.                 case 17:
  481.                 cs=cs+1;
  482.                 if(cs>23)
  483.                         cs=0;
  484.                 W_cmd(0x80+0x11);
  485.                 W_data(table[cs/10]);
  486.                 W_data(table[cs%10]);
  487.                 W_cmd(0x80+0x12);
  488.                 break;

  490.                 case 18:
  491.                 cf=cf+10;
  492.                 if(cf>59)
  493.                         cf=0;
  494.                 W_data(table[cf/10]);
  495.                 W_data(table[cf%10]);
  496.                 W_cmd(0x80+0x14);
  497.                 break;

  499.                 case 19:
  500.                 cf=cf+1;
  501.                 if(cf>59)
  502.                         cf=0;
  503.                 W_cmd(0x80+0x14);
  504.                 W_data(table[cf/10]);
  505.                 W_data(table[cf%10]);
  506.                 W_cmd(0x80+0x15);
  507.                 break;

  509.                 case 20:
  510.                 a=~a;
  511.                 if(a==1)
  512.                         t=0x4f;
  513.                 else
  514.                         t=0x58;
  515.                 W_cmd(0x80+0x17);
  516.                 W_data(t);
  517.                 W_cmd(0x80+0x17);
  518.                 break;

  520.                 case 21:
  521.                 for(c=0;c<16;c++)
  522.                 {
  523.                         W_cmd(0x1c);
  524.                         delay(150);
  525.                 }
  526.                 W_cmd(0x80+0x01);
  527.                 r=0;
  528.                 break;
  529.         }
  530. }
  531. void control()
  532. {
  533.         if(O==0)
  534.         {
  535.                 delay(10);
  536.                 if(O==0)
  537.                 {
  538.                         while(!O);
  539.                         TR0=0;
  540.                         W_cmd(0x0f);
  541.                         W_cmd(0x80+0x4e);
  542.                         W_data(0x43);
  543.                         W_cmd(0x80+0x01);
  544.                         while(1)
  545.                         {
  546.                                 if(O==0)
  547.                                 {
  548.                                         delay(10);
  549.                                         if(O==0)
  550.                                         {
  551.                                                 while(!O);
  552.                                                 TR0=1;
  553.                                                 r=0;
  554.                                                 init();
  555.                                                 break;
  556.                                         }
  557.                                 }
  558.                                 if(L==0)
  559.                                 {
  560.                                         delay(10);
  561.                                         if(L==0)
  562.                                         {
  563.                                                 while(!L);
  564.                                                 r--;
  565.                                                 if(r<0)
  566.                                                 {
  567.                                                         r=14;
  568.                                                         W_cmd(0x80+0x4b);
  569.                                                 }
  570.                                                 if(r>14&&r<16)
  571.                                                 {
  572.                                                         r=21;
  573.                                                         W_cmd(0x80+0x15);
  574.                                                 }
  575.                                                 control_move();
  576.                                         }
  577.                                 }
  578.                                 if(R==0)
  579.                                 {
  580.                                         delay(10);
  581.                                         if(R==0)
  582.                                         {
  583.                                                 while(!R);
  584.                                                 r++;
  585.                                                 if(r>14)
  586.                                                 {
  587.                                                         if(r<16)
  588.                                                         {
  589.                                                                 r=0;
  590.                                                                 W_cmd(0x80+0x01);
  591.                                                         }
  592.                                                         if(r>21)
  593.                                                         {
  594.                                                                 r=16;
  595.                                                                 W_cmd(0x80+0x11);
  596.                                                         }
  597.                                                 }
  598.                                                 control_move();
  599.                                         }
  600.                                 }
  601.                                 if(S==0)
  602.                                 {
  603.                                         delay(10);
  604.                                         if(S==0)
  605.                                         {
  606.                                                 while(!S);
  607.                                                 control_set();
  608.                                         }
  609.                                 }               
  610.                         }
  611.                         lcdshow();
  612.                 }
  613.         }
  614. }
  615. void count()
  616. {
  617.         if(num==20)
  618.         {
  619.                 m++;
  620.                 if(a==1)
  621.                 {
  622.                         if(cs==s)
  623.                         {
  624.                                 if(cf==f)
  625.                                 {
  626.                                         beep=~beep;
  627.                                 }
  628.                         }
  629.                 }
  630.                 num=0;
  631.                 if(m==60)
  632.                 {
  633.                         f++;
  634.                         m=0;
  635.                         if(f==60)
  636.                         {
  637.                                 beep=0;
  638.                                 s++;
  639.                                 f=0;
  640.                                 if(s==24)
  641.                                 {
  642.                                         s=0;
  643.                                         d++;
  644.                                         leap();
  645.                                         if(y>12)
  646.                                         {
  647.                                                 y=1;
  648.                                                 n++;
  649.                                                 if(n>9999)
  650.                                                         n=0;
  651.                                         }
  652.                                 }
  653.                         }
  654.                 }
  655.                 lcdshow();       
  656.         }
  657. }
  658. void main()
  659. {
  660.         init();
  661.         lcdshow();
  662.         while(1)
  663.         {
  664.                 count();
  665.                 control();
  666.         }
  667. }
  668. void Timer()interrupt 1
  669. {
  670.         TH0=(65536-46080)/256;
  671.         TL0=(65536-46080)%256;
  672.         num++;
  673. }
复制代码



评分

参与人数 1黑币 +50 收起 理由
admin + 50 回帖助人的奖励！

查看全部评分

回复

使用道具 举报

板凳
ID:86056 发表于 2015-7-23 11:48 | 只看该作者
程序如上，识别按键被按下，做对应的输出

评分

参与人数 1黑币 +50 收起 理由
admin + 50 回帖助人的奖励！

查看全部评分

回复

使用道具 举报

地板
ID:98756 发表于 2015-12-9 13:07 | 只看该作者
proteus7.8闹钟显示不对怎么办
回复

使用道具 举报

5#
ID:116303 发表于 2016-5-25 11:35 | 只看该作者
程序不错
回复

使用道具 举报

6#
ID:123210 发表于 2016-5-25 20:49 | 只看该作者
二楼写得不错
回复

使用道具 举报

7#
ID:123289 发表于 2016-5-26 12:12 | 只看该作者
方法:
设你的长按键叫CA,S就是你长按的时间门限值;
1,设定一个标记叫CAOK,=1时表示长按成功;
2,做一个按键计时器K,设定一个标记KY,约定KY=1时,由时间中断(如10ms)进行K+1;
实现:
1,每次检测时:有CA时KY=1.<起动计时器>
2,每次检测时:无CA时KY=1,K=0.KY=0<清计时器并清0>(必须多次检测,且间隔时间<<S);
3,当K=S时,置CAOK=1;
4,当CAOK被使用完成后,请记得清CAOK=0;
这样还不够,这里不说了.就是长按时间>S后的处理.留给你自己解决吧.

评分

参与人数 1黑币 +100 收起 理由
admin + 100 回帖助人的奖励！

查看全部评分

回复

使用道具 举报

8#
ID:84598 发表于 2016-5-26 17:27 | 只看该作者
yzwzfyz 发表于 2016-5-26 12:12
方法:
设你的长按键叫CA,S就是你长按的时间门限值;
1,设定一个标记叫CAOK,=1时表示长按成功;

好久之前写的东西了，这些功能后来已经实现了，还有1302，屏幕也换成12864了，已经移植到STM32上了，不过还是多谢了
回复

使用道具 举报

9#
ID:649345 发表于 2019-11-25 22:04 | 只看该作者
程序写的不错，就是二月份不管是什么年份都直接跳过了
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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