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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 1602 定时器 点扫描做万年历、时钟 走时精度已经可观
返回列表 发新帖
查看: 2157|回复: 0
打印 上一主题 下一主题
收起左侧

1602 定时器 点扫描做万年历、时钟 走时精度已经可观

[复制链接]
跳转到指定楼层
楼主
ID:155127 发表于 2016-12-15 21:46 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
仅使用内部定时器，走时精度已经可观。
难度在于使用键盘调节万年历。

下载：
1602 定时器 点扫描做时钟.rar (2.62 KB, 下载次数: 20)

  1. #include<reg52.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char
  4. uchar shi,fen,miao,ri,yue,nian,rimax,keyn,xq,flag;
  5. uint tt;
  6. uchar code table[]="2011-11-11 FRI";
  7. uchar code table1[]="23:59:51";
  8. uchar code tablex[]="MON TUE WED THU FRI SAT SUN ";
  9. sbit dula=P2^6;
  10. sbit wela=P2^7;
  11. sbit lcden=P3^4;
  12. sbit rs=P3^5;
  13. sbit key=P3^0;
  14. sbit keyg=P3^1;
  15. sbit keyd=P3^2;        //原计划写调减，不想写了。
  16. sbit gnd=P3^7;
  17. void init();
  18. void write_com(uchar com);
  19. void write_date(uchar date);
  20. void write_sfm(uchar wei,uchar date);
  21. void write_nyr(uchar wei,uchar date);
  22. void write_xq();
  23. void delay(uchar z);
  24. void yueday();
  25. void shunbianday();
  26. void keyscan();
  27. void clockrun();
  28. void main()
  29. {
  30.         init();
  31.         while(1)
  32.         {
  33.                 keyscan();
  34.                 clockrun();
  35.         }
  36. }

  38. void init()
  39. {
  40.         uchar a,b;

  42.         dula=0;
  43.         wela=0;
  44.         lcden=0;

  46.         shi=23;
  47.         fen=59;
  48.         miao=58;

  50.         nian=16;
  51.         yue=2;
  52.         ri=29;

  54.         keyn=0;

  56.         write_com(0x38);
  57.         write_com(0x0c);
  58.         write_com(0x06);
  59.         write_com(0x01);

  61.         write_com(0x80+1);
  62.         for(a=0;a<14;a++)
  63.         {
  64.                 write_date(table[a]);
  65.         }

  67.         write_com(0x80+0x40+4);
  68.         for(b=0;b<8;b++)
  69.         {
  70.                 write_date(table1[b]);
  71.         }

  73.         write_nyr(2,nian);
  74.         write_nyr(5,yue);
  75.         write_nyr(8,ri);
  76.         write_sfm(0,shi);
  77.         write_sfm(3,fen);
  78.         write_sfm(6,miao);

  80.         write_xq();

  82.         yueday();

  84.         TMOD=0x02;        //设定定时/计数器工作方式2，自动重装初值
  85.         TH0=0;        //高八位+1计数器，工作方式1中，(65536-46080)/256=高八位，高八位总共可以装256，减76后可装180，即：当低八位为零时，高八位加一计数器+1次数180次时刚好50ms
  86.         TL0=0;        //低八位+1计数器,工作方式2中，第八位用于+1计数完成计时，高八位用于保留初值给第八位重写初值
  87.         EA=1;        //现在因不需占用机器周期重装初值，若还有误差，则只能是晶振的误差
  88.         ET0=1;
  89.         TR0=1;
  90. }

  92. void timer0() interrupt 1
  93. {       
  94.         tt++;        //由于第八位加计数器只能计256，
  95. }

  97. void write_sfm(uchar wei,uchar date)
  98. {
  99.         uchar ge,shi;
  100.         shi=date/10;
  101.         ge=date%10;
  102.         write_com(0x80+0x40+4+wei);
  103.         write_date(0x30+shi);
  104.         write_date(0x30+ge);
  105. }

  107. void write_nyr(uchar wei,uchar date)
  108. {
  109.         uchar ge,shi;
  110.         shi=date/10;
  111.         ge=date%10;
  112.         write_com(0x80+1+wei);
  113.         write_date(0x30+shi);
  114.         write_date(0x30+ge);
  115. }

  117. void write_xq()        //写星期数
  118. {
  119.         uchar q;
  120.         write_com(0x80+12);
  121.         for(q=0;q<4;q++)
  122.         {
  123.                 write_date(tablex[xq]);
  124.                 xq++;
  125.                 if(xq==28)
  126.                         xq=0;
  127.         }
  128. }

  130. void yueday()        //程序写长了，改子函数名有困难，以后注意。
  131. {                                //该子函数表示月+1后计算引用的天数
  132.         if(yue==1)
  133.                 rimax=32;
  134.         if(yue==2)
  135.         {
  136.                 if(nian%4==0)
  137.                         rimax=30;
  138.                 else
  139.                         rimax=29;
  140.         }
  141.         if(yue==3)
  142.                 rimax=32;
  143.         if(yue==4)
  144.                 rimax=31;
  145.         if(yue==5)
  146.                 rimax=32;
  147.         if(yue==6)
  148.                 rimax=31;
  149.         if(yue==7)
  150.                 rimax=32;
  151.         if(yue==8)
  152.                 rimax=32;
  153.         if(yue==9)
  154.                 rimax=31;
  155.         if(yue==10)
  156.                 rimax=32;
  157.         if(yue==11)
  158.                 rimax=31;
  159.         if(yue==12)
  160.                 rimax=32;
  161. }

  163. void shunbianday()        //该子函数表示月+0后计算引用的天数
  164. {                       
  165.         if(yue==2)        //实际调用1月份天数最大31
  166.                         rimax=31;
  167.                 if(yue==3)        //实际调用2月份天数最大28/29
  168.                 {
  169.                         if(nian%4==0)
  170.                                 rimax=29;
  171.                         else
  172.                                 rimax=28;
  173.                 }
  174.                 if(yue==4)
  175.                         rimax=31;        //实际调用3月份天数最大31
  176.                 if(yue==5)
  177.                         rimax=30;        //实际调用4月份天数最大30
  178.                 if(yue==6)
  179.                         rimax=31;        //实际调用5月份天数最大31
  180.                 if(yue==7)
  181.                         rimax=30;        //实际调用6月份天数最大30
  182.                 if(yue==8)
  183.                         rimax=31;        //实际调用7月份天数最大31
  184.                 if(yue==9)
  185.                         rimax=31;        //实际调用8月份天数最大31
  186.                 if(yue==10)
  187.                         rimax=30;        //实际调用9月份天数最大30
  188.                 if(yue==11)
  189.                         rimax=31;        //实际调用10月份天数最大31
  190.                 if(yue==12)
  191.                         rimax=30;        //实际调用11月份天数最大30
  192. }

  194. void delay(uchar z)
  195. {
  196.         uchar i,j;
  197.         for(i=z;i>0;i--)
  198.                 for(j=115;j>0;j--);
  199. }

  201. void write_com(uchar com)
  202. {
  203.         rs=0;
  204.         P0=com;
  205.         delay(4);
  206.         lcden=1;
  207.         delay(4);
  208.         lcden=0;
  209. }

  211. void write_date(uchar date)
  212. {
  213.         rs=1;
  214.         P0=date;
  215.         delay(4);
  216.         lcden=1;
  217.         delay(4);
  218.         lcden=0;       
  219. }

  221. void keyscan()
  222. {
  223.         uchar temp,p;
  224.         gnd=0;
  225.         if(key==0)
  226.         {
  227.                 delay(5);
  228.                 if(key==0)
  229.                 {
  230.                         TR0=0;
  231.                         keyn++;
  232.                         if(keyn==7)
  233.                                 keyn=0;
  234.                         write_com(0x0f);
  235.                         if(keyn==0)
  236.                         {       
  237.                                 TR0=1;
  238.                                 write_com(0x0c);
  239.                         }
  240.                         if(keyn==1)
  241.                                 write_com(0x80+0x40+11);
  242.                         if(keyn==2)
  243.                                 write_com(0x80+0x40+8);
  244.                         if(keyn==3)
  245.                                 write_com(0x80+0x40+5);
  246.                         if(keyn==4)
  247.                                 write_com(0x80+10);
  248.                         if(keyn==5)
  249.                                 write_com(0x80+7);
  250.                         if(keyn==6)
  251.                                 write_com(0x80+4);
  252.                         while(!key);
  253.                 }
  254.         }
  255.         if(keyn==1)
  256.         {
  257.                 if(keyg==0)
  258.                 {
  259.                         delay(5);
  260.                         if(keyg==0)
  261.                         {
  262.                                 miao++;
  263.                                 if(miao==60)
  264.                                         miao=0;
  265.                                 write_sfm(6,miao);
  266.                                 write_com(0x80+0x40+11);
  267.                                 while(!keyg);
  268.                         }
  269.                 }
  270.         }
  271.         if(keyn==2)
  272.         {
  273.                 if(keyg==0)
  274.                 {
  275.                         delay(5);
  276.                         if(keyg==0)
  277.                         {
  278.                                 fen++;
  279.                                 if(fen==60)
  280.                                         fen=0;
  281.                                 write_sfm(3,fen);
  282.                                 write_com(0x80+0x40+8);
  283.                                 while(!keyg);
  284.                         }
  285.                 }
  286.         }
  287.         if(keyn==3)
  288.         {
  289.                 if(keyg==0)
  290.                 {
  291.                         delay(5);
  292.                         if(keyg==0)
  293.                         {
  294.                                 shi++;
  295.                                 if(shi==24)
  296.                                         shi=0;
  297.                                 write_sfm(0,shi);
  298.                                 write_com(0x80+0x40+5);
  299.                                 while(!keyg);
  300.                         }
  301.                 }
  302.         }
  303.         if(keyn==4)
  304.         {
  305.                 if(keyg==0)
  306.                 {
  307.                         delay(5);
  308.                         if(keyg==0)
  309.                         {
  310.                                 yueday();
  311.                                 ri++;
  312.                                 if(ri>=rimax)
  313.                                 {
  314.                                         ri=1;
  315.                                         temp=(rimax-2)%7;                                       
  316.                                         for(p=6-temp;p>0;p--)
  317.                                         {
  318.                                                 write_xq();                //因为跳出循环后，下面还会再重复一次，所以这里只循环5次
  319.                                         }
  320.                                 }
  321.                                 write_xq();

  323.                                 write_nyr(8,ri);
  324.                                 write_com(0x80+10);
  325.                                 while(!keyg);
  326.                         }
  327.                 }
  328.         }
  329.         if(keyn==5)
  330.         {
  331.                 if(keyg==0)
  332.                 {
  333.                         delay(5);
  334.                         if(keyg==0)
  335.                         {
  336.                                 yue++;
  337.                                 if(yue==13)
  338.                                 {
  339.                                         yue=1;        //情况二，跨月数调月（12变1）后，间隔天数
  340.                                         if(nian%4==0)        //情况二分支1,闰年
  341.                                         {        //因为12月、1月均为月大，日编号不会变
  342.                                                 for(p=(366-33)%7;p>0;p--)
  343.                                                         write_xq();       
  344.                                         }
  345.                                         else        //情况二分支2,平年
  346.                                         {
  347.                                                 for(p=(365-31)%7;p>0;p--)
  348.                                                         write_xq();               
  349.                                         }
  350.                                 }
  351.                                 write_nyr(5,yue);
  352.                                 //标记点
  353.                                 yueday();        //情况一，顺序调月后(1→12)，间隔天数。本句判断本月有多少天供后续利用
  354.                                 if(ri>rimax-1)        //情况一分支1。当当前显示的天数小于本月最大天数时，显示本月最大天数
  355.                                 {                               
  356.                                         write_nyr(8,rimax-1);        //上个注释的执行部分，将示数改到最大值范围
  357.                                         temp=ri-rimax;        //情况一分支1，判断当月数加一后，天数增加数量
  358.                                         ri=rimax-1;        //上个注释的执行部分，不能光改示数，而不改实际运行值。
  359.                                         shunbianday();        //更换rimax值
  360.                                         for(p=(rimax+temp-1)%7;p>0;p--)
  361.                                                 write_xq();       
  362.                                 }
  363.                                 else        //情况一分支2，判断当月数加一后，天数增加数量
  364.                                 {        //当初值大于29时，1月变2月，是顺变，同时显示值大于最大允许值
  365.                                         shunbianday();
  366.                                         for(p=rimax%7;p>0;p--)
  367.                                                 write_xq();       
  368.                                 }

  370.                                 write_com(0x80+7);
  371.                                 while(!keyg);
  372.                         }
  373.                 }
  374.         }
  375.         if(keyn==6)
  376.         {
  377.                 if(keyg==0)
  378.                 {
  379.                         delay(5);
  380.                         if(keyg==0)
  381.                         {
  382.                                 if(nian%4==0&&yue==2&&ri==29)        //分支3，当年+0为闰年2月29日时，年+1后2月只有28号。
  383.                                 {
  384.                                         ri=28;        //改日的值
  385.                                         write_nyr(8,ri);        //改日显示
  386.                                         for(p=7;p>0;p--)        //改星期显示       
  387.                                                 write_xq();                //循环七次，相当于没改
  388.                                         flag=1;        //分支4，当闰年2月29调过年数，调年再经过闰年未能识别闰年
  389.                                 }
  390.                                 nian++;
  391.                                 if(nian>99)        //分支1，嘿嘿，百年虫
  392.                                 {
  393.                                         nian=0;
  394.                                         write_xq();
  395.                                 }
  396.                                 if(nian%4==0)        //分支2.1,年+1为闰年
  397.                                 {
  398.                                         if(flag==1)
  399.                                         {
  400.                                                 for(p=(365-28)%7;p>0;p--)
  401.                                                         write_xq();
  402.                                                 flag=2;
  403.                                         }
  404.                                         else
  405.                                         {
  406.                                                 for(p=(366-35)%7;p>0;p--)
  407.                                                         write_xq();       
  408.                                         }
  409.                                 }
  410.                                 else        //分支2.2,年+1为平年
  411.                                 {
  412.                                         if(flag==2)
  413.                                         {
  414.                                                 for(p=2;p>0;p--)
  415.                                                         write_xq();
  416.                                                 flag=1;
  417.                                         }
  418.                                         else
  419.                                         {
  420.                                                 for(p=(365-28)%7;p>0;p--)
  421.                                                         write_xq();
  422.                                         }
  423.                                 }
  424.                                 write_nyr(2,nian);
  425.                                 write_com(0x80+4);
  426.                                 while(!keyg);
  427.                         }
  428.                 }
  429.         }
  430. }

  432. void clockrun()
  433. {
  434.         if(tt==3600)
  435.         {
  436.                 tt=0;
  437.                 miao++;
  438.                 if(miao>=60)
  439.                 {
  440.                         miao=0;
  441.                         fen++;
  442.                         if(fen>=60)
  443.                         {
  444.                                 fen=0;
  445.                                 shi++;
  446.                                 if(shi>=24)
  447.                                 {
  448.                                         shi=0;
  449.                                         ri++;
  450.                                         write_xq();
  451.                                         yueday();
  452.                                         if(ri>=rimax)
  453.                                         {
  454.                                                 ri=1;
  455.                                                 yue++;
  456.                                                 if(yue>=13)
  457.                                                 {
  458.                                                         yue=1;
  459.                                                         nian++;
  460.                                                         if(nian>=100)
  461.                                                                 nian=0;
  462.                                                         write_nyr(2,nian);
  463.                                                 }
  464.                                                 write_nyr(5,yue);
  465.                                         }
  466.                                         write_nyr(8,ri);
  467.                                 }
  468.                                 write_sfm(0,shi);
  469.                         }
  470.                         write_sfm(3,fen);
  471.                 }
  472.                 write_sfm(6,miao);
  473.         }
  474. }
复制代码


万年历, 定时器, 键盘
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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