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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 液晶显示日历的单片机程序
返回列表 发新帖
查看: 2058|回复: 1
打印 上一主题 下一主题
收起左侧

液晶显示日历的单片机程序

[复制链接]
跳转到指定楼层
楼主
ID:428902 发表于 2018-11-26 17:40 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
1、   日历功能
A、在此功能执行时，不可影响电子表的正常运行。
B、该模式下可显示年、月、日。
C、使用矩阵键盘调节时间。
D、满足特殊月份31、28天规律。
E、满足闰年规律。
2、   秒表功能
A、在此功能执行时，不可影响电子表的正常运行。
B、该模式下可实现秒表计时功能。
C、用一根杜邦线（结合程序）插入所需引脚，使得秒表停止计时，拔下杜邦线可继续计时（此要求下允许电子钟非正常运行，但不得人为不关闭任何定时器）。
3、定时功能
A、在此功能执行时，不可影响电子表的正常运行。

单片机源程序如下:
  1. #include<reg52.h>
  2. #define uchar unsigned char
  3. #define uint unsigned int
  4. uint year,year1;
  5. uchar code table[]={"2018-11-07week3"};
  6. uchar code table1[]={"19:29:55 "};         
  7. uchar code table2[]={"0:00:00 "};                  
  8. sbit lcden=P3^4;        //定义液晶使能端
  9. sbit lcdrs=P3^5;        //液晶数据命令选择端
  10. sbit rw=P3^6;                //定义读写选择
  11. sbit k0=P3^5;               
  12. sbit dula=P2^6;                //声明U1锁存端，锁存器
  13. sbit wela=P2^7;                //声明U2锁存端，锁存器
  14. sbit beep=P2^3;
  15. uchar num,num1,a,a2,b,du,shi,shi1,fen,miao,ge,day,mon,week;
  16. uchar flag,flag1,shi,shi2,fen1,miao1,a1,du1,qie,du2,num3,num4;


  19. void delay(uint z)
  20. {
  21.         uint x,y;
  22.         for(x=z;x>0;x--)
  23.                  for(y=110;y>0;y--);
  24. }

  26. void write_com(uchar com)        //写命令操作
  27. {
  28.         rw=0;
  29.         lcdrs=0;        //选择写命令模式
  30.         P0=com;                //将要写的命令字，送到数据总线上
  31.         delay(5);        //稍作延时以待数据稳定
  32.         lcden=1;        //使能端，给一高脉冲，因为初始化函数，已经将使能端置为0
  33.         delay(5);        //稍作延时
  34.         lcden=0;        //使能端0完成高脉冲
  35. }

  37. void write_data(uint date1)                  //写数据操作
  38. {
  39.         rw=0;
  40.         lcdrs=1;
  41.         P0=date1; //写数据
  42.         delay(5);
  43.         lcden=1;
  44.         delay(5);
  45.         lcden=0;
  46. }

  48. void write_sfm(uchar add,uint date1)         //定义小时，分钟，秒的地址和数据
  49. {
  50.         uchar shi,ge;
  51.         shi=date1/10; //将数据分离
  52.         ge=date1%10;

  54.         write_com(0x80+0x40+add);//第二行数据指针位置调整
  55.         write_data(0x30+shi);  //更改显示数据的十位
  56.         write_data(0x30+ge);   //更改显示数据的个位

  58. }

  60. void write_md(uchar add,uint date1)         //定义月份和天地址和数据
  61. {
  62.         uchar shi,ge;
  63.         shi=date1/10; //将数据分离
  64.         ge=date1%10;

  66.         write_com(0x80+add);   //第一行数据指针位置调整
  67.         write_data(0x30+shi);  //更改显示数据的十位
  68.         write_data(0x30+ge);   //更改显示数据的个位
  69. }


  72. void write_y(uchar add,uint date1)         //定义年地址和数据
  73. {
  74.         uchar qian,bai,shi,ge;
  75.         qian=date1/1000;
  76.         bai=date1%1000/100;
  77.         shi=date1%100/10; //将数据分离
  78.         ge=date1%10;

  80.         write_com(0x80+add);//第一行数据指针位置调整
  81.         write_data(0x30+qian);  //更改显示数据的千位
  82.         write_data(0x30+bai);  //更改显示数据的百位
  83.         write_data(0x30+shi);  //更改显示数据的十位
  84.         write_data(0x30+ge);   //更改显示数据的个位
  85. }

  87. //void zhuanhua()
  88. //{
  89. //        switch(week)
  90. //        {
  91. //                case 1:
  92. //                        write_com(0x80+0x40+9);
  93. //                        write_data('M');  delay(5);
  94. //                        write_data('o');  delay(5);
  95. //                        write_data('n');  delay(5);
  96. //                        write_data('d');  delay(5);
  97. //                        write_data('a');  delay(5);
  98. //                        write_data('y');  delay(5);
  99. //                        write_data(' ');
  100. //                        break;
  101. //                case 2:
  102. //                        write_com(0x80+0x40+9);
  103. //                        write_data('T');  delay(5);
  104. //                        write_data('u');  delay(5);
  105. //                        write_data('e');  delay(5);
  106. //                        write_data('s');  delay(5);
  107. //                        write_data('d');  delay(5);
  108. //                        write_data('a');  delay(5);
  109. //                        write_data('y');
  110. //                        break;        
  111. //                case 3:
  112. //                        write_com(0x80+0x40+9);
  113. //                        write_data('W');  delay(5);
  114. //                        write_data('e');  delay(5);
  115. //                        write_data('d');  delay(5);
  116. //                        write_data('n');  delay(5);
  117. //                        write_data('e');  delay(5);
  118. //                        write_data('s');  delay(5);
  119. //                        write_data('d');  
  120. //                        break;               
  121. //                case 4:
  122. //                        write_com(0x80+0x40+9);
  123. //                        write_data('T');  delay(5);
  124. //                        write_data('h');  delay(5);
  125. //                        write_data('u');  delay(5);
  126. //                        write_data('r');  delay(5);
  127. //                        write_data('s');  delay(5);
  128. //                        write_data('d');  delay(5);
  129. //                        write_data('a');
  130. //                        break;        
  131. //                case 5:
  132. //                        write_com(0x80+0x40+9);
  133. //                        write_data('F');  delay(5);
  134. //                        write_data('r');  delay(5);
  135. //                        write_data('i');  delay(5);
  136. //                        write_data('d');  delay(5);
  137. //                        write_data('a');  delay(5);
  138. //                        write_data('y');  delay(5);
  139. //                        write_data(' ');
  140. //                        break;        
  141. //                case 6:
  142. //                        write_com(0x80+0x40+9);
  143. //                        write_data('S');  delay(5);
  144. //                        write_data('a');  delay(5);
  145. //                        write_data('t');  delay(5);
  146. //                        write_data('u');  delay(5);
  147. //                        write_data('r');  delay(5);
  148. //                        write_data('d');  delay(5);
  149. //                        write_data('a');  
  150. //                        break;        
  151. //                case 7:
  152. //                        write_com(0x80+0x40+9);
  153. //                        write_data('S');  delay(5);
  154. //                        write_data('u');  delay(5);
  155. //                        write_data('n');  delay(5);
  156. //                        write_data('d');  delay(5);
  157. //                        write_data('a');  delay(5);
  158. //                        write_data('y');  delay(5);
  159. //                        write_data(' ');
  160. //                        break;                        
  161. //        }
  162. //}

  164. void jianpan()
  165. {
  166.           uchar temp;
  167.           P3=0xfe;
  168.           temp=P3;
  169.           temp=temp&0xf0;
  170.           if(temp!=0xf0)
  171.           {
  172.                   delay(10);
  173.                 temp=P3;
  174.                 temp=temp&0xf0;
  175.                  if(temp!=0xf0)
  176.                  {
  177.                          temp=P3;
  178.                         switch(temp)
  179.                         {
  180.                                 case 0xee:         //显示需要更改地方的光标
  181.                                         du++;
  182.                                         while(temp!=0xf0)  //按键释放，使每按一次只增加一个数
  183.                                         {
  184.                                                 temp=P3;
  185.                                                 temp=temp&0xf0;
  186.                                         }
  187.                                         if(du==1)         //移动光标至秒位置，同时暂停计时
  188.                                         {
  189.                                                 TR0=0;
  190.                                                 write_com(0x80+0x40+6);
  191.                                                 write_com(0x0f);   //显示光标
  192.                                         }
  193.                                         if(du==2)            //移动光标至分位置
  194.                                         {        
  195.                                                 write_com(0x80+0x40+3);
  196.                                         }
  197.                                         if(du==3)                 //移动光标至时位置
  198.                                         {        
  199.                                                 write_com(0x80+0x40+0);
  200.                                         }        
  201.                                         if(du==4)                 //移动光标至天位置
  202.                                         {
  203.                                                 write_com(0x80+8);                                
  204.                                         }        
  205.                                         if(du==5)                  //移动光标至月位置
  206.                                         {        
  207.                                                 write_com(0x80+5);
  208.                                         }               
  209.                                         if(du==6)                  //移动光标至年位置，用于 增加年份
  210.                                         {        
  211.                                                 write_com(0x80+0);
  212.                                         }        
  213.                                         if(du==7)                  //移动光标至周位置
  214.                                         {
  215.                                                 write_com(0x80+14);   //先送地址
  216. //                                                write_data(0x30+week);        //输入的数字
  217.                                         }
  218.                                         if(du==8)                   //移动光标至年位置        减少年份
  219.                                         {        
  220.                                                 write_com(0x80+0);
  221.                                         }                                       
  222.                                         if(du==9)                   //使du循环，恢复定时器
  223.                                         {                                
  224.                                                 TR0=1;
  225.                                                 du=0;
  226.                                                 write_com(0x80+0x40+10);
  227.                                                 write_com(0x0c);   //关光标
  228.                                         }                                                
  229.                         
  230.                                         break;
  231.                                         case 0xde:
  232.                                                 while(temp!=0xf0)          //按键释放
  233.                                                 {
  234.                                                         temp=P3;
  235.                                                         temp=temp&0xf0;
  236.                                                 }
  237.                                                 if(du==1)        //在秒位置时，使秒增加
  238.                                                 {
  239.                                                         miao++;
  240.                                                         if(miao==60)
  241.                                                         {
  242.                                                                 miao=0;
  243.                                                         }
  244.                                                         write_sfm(6,miao);        //更新秒位置数据
  245.                                                 }
  246.                                                 if(du==2)                //在分位置时，使分增加
  247.                                                 {        
  248.                                                         fen++;
  249.                                                         if(fen==60)
  250.                                                         {
  251.                                                                 fen=0;
  252.                                                         }
  253.                                                         write_sfm(3,fen);  //更新秒位置数据
  254.                                                 }
  255.                                                 if(du==3)          //在小时位置时，使小时增加
  256.                                                 {        
  257.                                                         shi++;
  258.                                                         if(shi==24)
  259.                                                         {
  260.                                                                 shi=0;
  261.                                                         }
  262.                                                         if(flag1==0)   //显示24小时模式
  263.                                                         {
  264.                                                                 write_sfm(0,shi);
  265.                                                         }
  266.                                                         if(flag1==1)   //显示12小时模式
  267.                                                         {
  268.                                                                 if(shi==0)
  269.                                                                 {
  270.                                                                         shi=12;
  271.                                                                 }
  272.                                                                 if((shi<=12)&&(shi>=1))
  273.                                                                 {
  274.                                                                         shi1=shi;
  275.                                                                 }
  276.                                                                 if(shi>12)
  277.                                                                 {
  278.                                                                         shi1=shi-12;
  279.                                                                 }
  280.                                                                 write_sfm(0,shi1);           //更新12小时模式的数据
  281.                                                                 write_com(0x80+0x40+0);               
  282.                                                         }
  283.                                                 }        
  284.                                                 if(du==4)           //在天位置时，使天增加
  285.                                                 {
  286.                                                         day++;
  287.                                                         if(year%4==0&&year%10!=0)                        //如果是闰年
  288.                                                                 {
  289.                                                                         if(mon==2)
  290.                                                                         {
  291.                                                                                 if(day==30)
  292.                                                                                 {
  293.                                                                                         day=1;                                                
  294.                                                                                 }
  295.                                                                         }
  296.                                                                 }
  297.                                                         if((year%4==0&&year%100==0)||(year%4!=0))                 //如果不是闰年
  298.                                                                 {
  299.                                                                         if(mon==2)  
  300.                                                                         {
  301.                                                                                 if(day==29)         
  302.                                                                                 {                  
  303.                                                                                         day=1;                                                               
  304.                                                                                 }
  305.                                                                         }
  306.                                                                 }        
  307.                                 
  308.                                                                 if(mon==1||mon==3||mon==5||mon==7||mon==8||mon==10||mon==12)
  309.                                                                 {
  310.                                                                         if(day==32)
  311.                                                                         {
  312.                                                                                 day=1;                                                
  313.                                                                         }
  314.                                                                 }
  315.                                                                 if(mon==4||mon==6||mon==9||mon==11)
  316.                                                                 {
  317.                                                                         if(day==31)
  318.                                                                         {
  319.                                                                                 day=1;                                                
  320.                                                                         }
  321.                                                                 }
  322.                                                         write_md(8,day);                        
  323.                                                 }        
  324.                                                 if(du==5)        //在月位置时，使月增加
  325.                                                 {        
  326.                                                         mon++;
  327.                                                         if(mon==13)
  328.                                                         {
  329.                                                                 mon=1;
  330.                                                         }
  331.                                                         write_md(5,mon);
  332.                                                 }               
  333.                                                 if(du==6)         //在年位置时，使年增加
  334.                                                 {        
  335.                                                         year++;
  336.                                                         write_y(0,year);
  337.                                                 }
  338.                                                 if(du==7)          //在周位置时，使周增加
  339.                                                 {                          
  340.                                                         week++;
  341.                                                         if(week==8)
  342.                                                         {
  343.                                                                 week=1;
  344.                                                         }
  345.                                                         write_com(0x80+14);   //位置
  346.                                                         write_data(0x30+week);  //显示数据

  348.                                                 }
  349.                                                 if(du==8)        //在天位置时，使年减少
  350.                                                 {        
  351.                                                         year--;
  352.                                                         write_y(0,year);
  353.                                                 }
  354.                                                 break;

  356.                                         case 0xbe:
  357.                                                 flag1++;         //使变量flag1++
  358.                                                 while(temp!=0xf0)
  359.                                                 {
  360.                                                         temp=P3;
  361.                                                         temp=temp&0xf0;
  362.                                                 }
  363.                                                 if(flag1==1)         //如果变量flag1为1那么进行12小时模式
  364.                                                 {
  365.                                                         if(shi==0)
  366.                                                         {
  367.                                                                 shi=12;
  368.                                                         }
  369.                                                         if((shi<=12)&&(shi>=1))
  370.                                                         {
  371.                                                                 write_com(0x80+0x40+8);
  372.                                                                 write_data('+');
  373.                                                                 shi1=shi;
  374.                                                         }
  375.                                                         if(shi>12)
  376.                                                         {
  377.                                                                 write_com(0x80+0x40+8);
  378.                                                                 write_data('-');
  379.                                                                 shi1=shi-12;
  380.                                                         }
  381.                                                         write_sfm(0,shi1);
  382.                                                         write_com(0x80+0x40+0);        
  383.                                                 }
  384.                                                 if(flag1>=2)
  385.                                                 {
  386.                                                         flag1=0;
  387.                                                 }
  388.                                                 if(flag1==0)         //如果变量flag1为1那么进行24小时模式
  389.                                                 {
  390.                                                                 write_sfm(0,shi);
  391.                                                         write_com(0x80+0x40+0);        
  392.                                                 }
  393.                                                 break;        
  394.                                 case 0x7e:
  395.                                         du1++;                //使du1++
  396.                                         while(temp!=0xf0)
  397.                                         {
  398.                                                 temp=P3;
  399.                                                 temp=temp&0xf0;
  400.                                         }               
  401.                                         if(du1==1)          //使定时器1暂停，移动光标至秒表秒位
  402.                                         {
  403.                                                 write_com(0x80+0x40+14);
  404.                                                 TR1=0;
  405.                                                 write_com(0x0f);//显示光标        
  406.                                         }        
  407.                                         if(du1==2)           //移动光标至秒表 分 位
  408.                                         {
  409.                                                 write_com(0x80+0x40+11);        
  410.                                         }        
  411.                                         if(du1==3)                //时 位
  412.                                         {
  413.                                                 write_com(0x80+0x40+9);        
  414.                                         }        
  415.                                         if(du1==4)          //恢复定时器1，返回原位
  416.                                         {
  417.                                                 write_com(0x80+0x40+14);        
  418.                                                 TR1=1;
  419.                                                 write_com(0x0c);  //关闭光标显示
  420.                                         }        
  421.                                         if(du1==5)
  422.                                         {
  423.                                                 du1=0;
  424.                                         }                                                                                                
  425.                                         break;
  426.                         }
  427.                  }
  428.           }
  429.         P3=0xfd;
  430.         temp=P3;
  431.         temp=temp&0xf0;
  432.         if(temp!=0xf0)
  433.         {
  434.                 delay(10);
  435.                 temp=P3;
  436.                 temp=temp&0xf0;
  437.                 if(temp!=0xf0)
  438.                 {
  439.                          temp=P3;
  440.                         switch(temp)
  441.                         {
  442.                                 case 0xed:
  443.                                         while(temp!=0xf0)
  444.                                         {
  445.                                                 temp=P3;
  446.                                                 temp=temp&0xf0;
  447.                                         }        
  448.                                         if(du1==1)
  449.                                         {
  450.                                                 miao1++;   //使秒表光标所在地 秒 加
  451.                                                 if(miao1==60)
  452.                                                 {
  453.                                                         miao1=0;
  454.                                                 }        
  455.                                                 write_sfm(14,miao1);   //更新
  456.                                         }        
  457.                                         if(du1==2)                //分 加
  458.                                         {
  459.                                                 fen1++;
  460.                                                 if(fen1==60)
  461.                                                 {
  462.                                                         fen1=0;
  463.                                                 }        
  464.                                                 write_sfm(11,fen1);
  465.                                         }        
  466.                                         if(du1==3)                //时 加
  467.                                         {
  468.                                                 shi2++;
  469.                                                 if(shi2==60)
  470.                                                 {
  471.                                                         shi2=0;
  472.                                                 }

  474.                                                 write_com(0x80+0x40+9);//第二行数据指针位置调整
  475.                                                 write_data(0x30+shi2);   //更改显示数据的个位
  476.                                         }               
  477.                                         break;

  479.                                 case 0xdd:        
  480.                                         TR1=1;        //开启秒表（初始值正走）                                
  481.                                         break;
  482.                                 case 0xbd:        
  483.                                         qie=1;        //切换 秒表 至倒计时                                       
  484.                                         break;
  485.                                 case 0x7d:        
  486.                                         num4=0;        //切换闹钟铃声 一直响                                       
  487.                                         break;
  488.                         }
  489.             }
  490.         }
  491.         P3=0xfb;
  492.         temp=P3;
  493.         temp=temp&0xf0;
  494.         if(temp!=0xf0)
  495.         {
  496.                 delay(10);
  497.                 temp=P3;
  498.                 temp=temp&0xf0;
  499.                 if(temp!=0xf0)
  500.                 {
  501.                          temp=P3;
  502.                         switch(temp)
  503.                         {
  504.                                 case 0xeb:
  505.                                         num4=1;        //切换闹钟铃声 间断响        
  506.                                         break;
  507.                                 case 0xdb:
  508.                                         qie=0;        //切换 秒表 正计时
  509.                                         break;
  510.                                 case 0xbb:
  511.                                         TR1=0;        //使秒表停止计时
  512.                                         break;
  513.                         }
  514.                 }
  515.         }
  516. }


  519. void shixu1()   //定时器1 秒表 正走时序
  520. {
  521.         if(a1==20)
  522.         {
  523.                 a1=0;
  524.                 miao1++;
  525.                 if(miao1==60)
  526.                 {
  527.                         miao1=0;
  528.                         fen1++;
  529.                         if(fen1==60)
  530.                         {
  531.                                 fen1=0;
  532.                                 shi2++;
  533.                         
  534.                                 if(shi2==10)
  535.                                 {
  536.                                         shi2=0;
  537.                                 }
  538.                                 write_com(0x80+0x40+9);//第二行数据指针位置调整
  539.                                 write_data(0x30+shi2);   //更改显示数据的个位
  540.                         }
  541.                         write_sfm(11,fen1);
  542.                 }
  543.                 write_sfm(14,miao1);
  544.         }        
  545. }
  546. void shixu2()          //定时器1 秒表 倒走时序
  547. {
  548.         if(a1==20)
  549.         {
  550.                 a1=0;
  551.                 miao1--;
  552.                 if(miao1==0&&fen1>=1&&shi2>=1)         //如果在秒为0，时和分钟不为零的情况下
  553.                 {
  554.                         miao1=59;
  555.                         fen1--;
  556.                         if(fen1==0&&shi2>=1)         //如果在分为0，分钟不为零的情况下
  557.                         {
  558.                                 fen1=59;
  559.                                 shi2--;

  561.                                 write_com(0x80+0x40+9);//第二行数据指针位置调整
  562.                                 write_data(0x30+shi2);   //更改显示数据的个位
  563.                         }
  564.                         write_sfm(11,fen1);
  565.                 }
  566.                 write_sfm(14,miao1);
  567.         }        
  568. }

  570. void shixu()   //日历走时序
  571. {
  572.         if(a==20)
  573.         {
  574.                 a=0;
  575.                 miao++;
  576.                 if(miao==60)
  577.                 {
  578.                         miao=0;
  579.                         fen++;
  580.                         if(fen==60)
  581.                         {
  582.                                 fen=0;
  583.                                 shi++;
  584.                                 if(shi==24)
  585.                                 {
  586.                                         shi=0;
  587.                                         day++;
  588.                                         week++;
  589.                                         if(week==7)
  590.                                         {
  591.                                                 week=1;        
  592.                                         }
  593.                                         if(year%4==0&&year%100!=0)        //如果是闰年
  594.                                         {
  595.                                                 if(mon==2)
  596.                                                 {
  597.                                                         if(day==30)
  598.                                                         {
  599.                                                                 day=1;
  600.                                                                 mon++;        
  601.                                                                
  602.                                                                 write_md(5,mon);                                                
  603.                                                         }
  604.                                                 }
  605.                                         }
  606.                                         if((year%4==0&&year%100==0)||(year%4!=0)) //如果不是闰年
  607.                                         {
  608.                                                 if(mon==29)
  609.                                                 {
  610.                                                         if(day==30)
  611.                                                         {
  612.                                                                 day=1;
  613.                                                                 mon++;
  614.                                                                
  615.                                                                 write_md(5,mon);                                                        
  616.                                                         }
  617.                                                 }
  618.                                         }        

  620.                                         if(mon==1||mon==3||mon==5||mon==7||mon==8||mon==10||mon==12)
  621.                                         {
  622.                                                 if(day==32)
  623.                                                 {
  624.                                                         day=1;
  625.                                                         mon++;        
  626.                                                         
  627.                                                         write_md(5,mon);                                                
  628.                                                 }
  629.                                         }
  630.                                         if(mon==4||mon==6||mon==9||mon==11)
  631.                                         {
  632.                                                 if(day==31)
  633.                                                 {
  634.                                                         day=1;
  635.                                                         mon++;
  636.                                                         
  637.                                                         write_md(5,mon);                                                        
  638.                                                 }
  639.                                         }
  640.                                 
  641.                                         if(mon==13)
  642.                                         {
  643.                                                 mon=1;
  644.                                                 year++;

  646.                                             write_y(1,year);
  647.                                         }
  648.                                         write_com(0x80+14);   //位置
  649.                                         write_data(0x30+week);  //显示数据
  650. //                                        zhuanhua();
  651.                                         write_md(8,day);                                                                                
  652.                                 }
  653.                                 if(flag1==0)        //切换至24小时模式
  654.                                 {
  655.                                         write_sfm(0,shi);
  656.                                 }
  657.                                 if(flag1==1) //切换至12小时模式
  658.                                 {
  659.                                         if(shi==0)
  660.                                         {
  661.                                                 shi=12;
  662.                                         }
  663.                                         if((shi<=12)&&(shi>=1))
  664.                                         {
  665.                                                 shi1=shi;
  666.                                         }
  667.                                         if(shi>12)
  668.                                         {
  669.                                                 shi1=shi-12;
  670.                                         }
  671.                                         write_sfm(0,shi1);        
  672.                                 }
  673.                         }
  674.                         write_sfm(3,fen);
  675.                 }
  676.                 write_sfm(6,miao);
  677.         }
  678. }
  679.          
  680. void main()
  681. {        
  682.         TMOD=0x11;
  683.         TH0=(65536-45872)/256;
  684.         TL0=(65536-45872)%256;
  685.         TH1=(65536-45872)/256;
  686.         TL1=(65536-45872)%256;
  687.         EA=1;
  688.         ET0=1;
  689.         TR0=1; //定时器0
  690.         ET1=1;
  691.         TR1=0;                        //定时器1，初始关闭运行
  692.         EX0=1;        //外部中断0中断允许位
  693.         IT0=0;        //外部中断0电平触发方式

  695.         shi=19;                //日历初值
  696.         fen=29;
  697.         miao=55;
  698.         day=6;
  699.         mon=11;
  700.         year=2018;
  701.         week=3;

  703.         flag1=0;  //小时为24制
  704.         num4=0;         //闹钟声为1号
  705.         qie=0;        //秒表开启时先为正走

  707.         dula=0;        //关闭段选
  708.         wela=0;        //关闭位选

  710.         lcden=0;           //使能端制0


  713.         write_com(0x38);
  714.         write_com(0x0c);  //开显示，不显示光标
  715.         write_com(0x06);   //写一个地址之后，指针加一
  716.         write_com(0x01);        //显示清0，数据指针清0

  718.         write_com(0x80);        //第一个行显示
  719.         {
  720.                 for(num=0;num<15;num++)
  721.                 {
  722.                         write_data(table[num]);
  723.                         delay(5);               
  724.                 }
  725.                 write_com(0x80+0x40);  //第一个行显示，左边显示数组
  726.                 for(num=0;num<13;num++)
  727.                 {                                                                                                                              
  728.                         write_data(table1[num]);
  729.                         delay(5);                        
  730.                 }
  731.         }
  732.                 write_com(0x80+0x40+9);         //第一个行显示，右边显示数组
  733.                 for(num=0;num<13;num++)
  734.                 {                                                                                                                              
  735.                         write_data(table2[num]);
  736.                         delay(5);                        
  737.                 }        
  738. //                zhuanhua();
  739.         while(1)
  740.         {        
  741.                 jianpan();
  742.                 shixu();

  744.                 if(qie==0)
  745.                 {
  746.                         shixu1(); //秒表正走
  747.                 }
  748.                 if(qie==1)
  749.                 {
  750.                         shixu2();         //秒表倒走
  751.                         if(shi2==0&&fen1==0&&miao1==0)//如果走到0，那么定时器1 暂停k
  752.                         {                        
  753.                                 TR1=0;
  754.                         }
  755.                 }
  756.         }
  757. }
  758.   
  759. void T0_time() interrupt 1        //定时器 中断服务程序k
  760. {
  761.         TH0=(65536-45872)/256;
  762.         TL0=(65536-45872)%256;
  763.         a++;

  765.         if((shi==19&&fen==30)&&(miao<3&&miao>=0))        //如果是在下午19点，30分，那么闹钟响铃3分钟k
  766.         {
  767.                 if(num4==0)                //闹钟铃声1，一直响k
  768.                 {
  769.                         {
  770.                                 beep=0;
  771.                         }
  772.                 }
  773.                 if(num4==1)          //闹钟铃声2，响一秒间断一秒再一秒k
  774.                 {
  775.                         if(miao==0)
  776.                         {
  777.                                 beep=0;
  778.                         }
  779.                         if(miao==1)
  780.                         {
  781.                                 beep=1;
  782.                         }
  783.                         if(miao==2)
  784.                         {
  785.                                 beep=0;
  786.                         }
  787.                 }
  788.         }

  790.         if(shi==19&&fen==30&&miao==3)
  791.         {
  792.                 beep=1;
  793.         }

  795. }

  797. void T1_time() interrupt 3        //定时器1 中断服务程序k
  798. {
  799.         TH1=(65536-45872)/256;
  800.         TL1=(65536-45872)%256;
  801.         a1++;
  802. }

  804.         

  806. void INT0_0() interrupt 0  //外部中断默认中断级别最高A
  807. {
  808. //   TR1=0;        
  809. }



复制代码

所有资料51hei提供下载:
日历.docx (19.08 KB, 下载次数: 11)



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

使用道具 举报

沙发
ID:1 发表于 2018-11-26 21:51 | 只看该作者
补全原理图或者详细说明一下电路连接即可获得100+黑币
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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