標(biāo)題: 單片機(jī)萬年歷仿真及源程序和protel畫的原理圖 [打印本頁]
作者: 51黑ff    時(shí)間: 2016-9-25 23:23
標(biāo)題: 單片機(jī)萬年歷仿真及源程序和protel畫的原理圖

萬年歷的所有資料下載：
萬年歷.zip (118.48 KB, 下載次數(shù): 48)

源程序：
  1. #include<reg52.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char
  4. uchar code table[]={"0000-00-00"};
  5. uchar code table1[]={"00:00:00"};
  6. uchar code table2[]={"MONTUSWEDTHUFRISATSUN"};
  7. sbit rs=P2^0;
  8. sbit rw=P2^1;
  9. sbit e=P2^2;
  10. sbit key1=P2^3;
  11. sbit key2=P2^4;
  12. sbit key3=P2^5;
  13. char num,shi1=0,fen=0,miao=0,ri=0,yue=0;uchar xingqi=1;
  14. int nianqian=0,nianhou=0;
  15. void delay(unsigned int z)
  16. {
  17.         uchar x,y;
  18.         for(x=z;x>0;x--)
  19.                 for(y=110;y>0;y--);
  20. }
  21. void write_com(uchar com)
  22. {
  23.         
  24.         rs=0;
  25.         rw=0;
  26.         P0=com;
  27.         delay(5);
  28.         e=1;
  29.         delay(5);
  30.         e=0;        
  31. }
  32. void write_data(uchar date)
  33. {
  34. rs=1;
  35. rw=0;
  36. P0=date;
  37. delay(5);
  38. e=1;
  39. delay(5);
  40. e=0;
  41. }
  42. void init()
  43. {         
  44.         rs=0;
  45.         write_com(0x38);
  46.         write_com(0x0c);
  47.         write_com(0x06);
  48.         write_com(0x01);
  49.         delay(5);
  50. }
  51. void write_wang(uchar add,uchar date)
  52. {
  53.         uchar shi,ge;
  54.         shi=date/10;
  55.         ge=date%10;
  56.         write_com(0x80+0X40+add);
  57.         write_data(0x30+shi);
  58.         write_data(0x30+ge);
  59.         
  60. }
  61. void write_wang1(uchar add,uchar date)
  62. {
  63.         uchar shi,ge;
  64.         shi=date/10;
  65.         ge=date%10;
  66.         write_com(0x80+add);
  67.         write_data(0x30+shi);
  68.         write_data(0x30+ge);        
  69. }
  70. void write_wang2(uchar add,int date)
  71. {
  72.         uchar shi,ge;
  73.         shi=date/10;
  74.         ge=date%10;
  75.         write_com(0x80+add);
  76.         write_data(0x30+shi);
  77.         write_data(0x30+ge);        
  78. }
  79. void keycan()
  80. {
  81.         uchar i;uchar num1;
  82.         if(key1==0)
  83.         {        
  84.                 delay(1);
  85.                 if(key1==0)
  86.                 {               
  87.                         num1++;
  88.                         while(!key1);
  89.                         if(num1==1)
  90.                         {
  91.                                 TR0=0;
  92.                                 write_com(0x80+0x40+7);
  93.                                 write_com(0x0f);
  94.                         }
  95.                 }         
  96.                         if(num1==2)
  97.                         {
  98.                         write_com(0x80+0x40+4);                        
  99.                         }
  100.                         if(num1==3)
  101.                         {
  102.                                 write_com(0x80+0x40+1);
  103.                         
  104.                         }
  105.                         if(num1==4)
  106.                         {        
  107.                                 write_com(0x80+9);        
  108.                         }
  109.                         if(num1==5)
  110.                         write_com(0x80+6);
  111.                         if(num1==6)
  112.                         write_com(0x80+3);
  113.                         if(num1==7)
  114.                         write_com(0x80+1);
  115.                         if(num1==8)
  116.                            write_com(0x80+13);
  117.                         if(num1>=9)
  118.                         {
  119.                         num1=0;
  120.                         TR0=1;
  121.                         write_com(0x0c);               
  122.                         }                                          
  123.         }         
  124.         if(num1!=0)
  125.                 {
  126.                  if(key2==0)
  127.                         {
  128.                                 delay(1);
  129.                                 if(key2==0)
  130.                                 {
  131.                                         while(key2!=1);
  132.                                         if(num1==1)
  133.                                         {
  134.                                         miao++;
  135.                                         if(miao==60)
  136.                                                 {
  137.                                                 miao=0;
  138.                                                 }
  139.                                         write_wang(6,miao);
  140.                                         write_com(0x80+0x40+6);
  141.                                         }        
  142.                                         if(num1==2)
  143.                                         {
  144.                                         fen++;
  145.                                                 if(fen==60)
  146.                                                 {
  147.                                                 fen=0;
  148.                                                 }
  149.                                         write_wang(3,fen);
  150.                                         write_com(0x80+0x40+3);
  151.                                         }
  152.                                         if(num1==3)
  153.                                         {
  154.                                         shi1++;
  155.                                                 if(shi1==24)
  156.                                                 {
  157.                                                 shi1=0;
  158.                                                 }
  159.                                                 write_wang(0,shi1);
  160.                                         write_com(0x80+0x40);
  161.                                         }
  162.                                         if(num1==4)
  163.                                         {
  164.                                         ri++;
  165.                                         if(yue==1||yue==3||yue==5||yue==7||yue==8||yue==10||yue==12)
  166.                                         {
  167.                                                 if(ri==32)
  168.                                                 {
  169.                                                 ri=1;
  170.                                                 }
  171.                                         }
  172.                                         else if(yue==2)
  173.                                                 {         
  174.                                                  if((nianqian*100+nianhou)%4==0 && (nianqian*100+nianhou)%100!=0 || (nianqian*100+nianhou)%400==0 )
  175.                                                         {
  176.                                                                 if(ri==30)
  177.                                                                 ri=1;
  178.                                                         }
  179.                                                         else
  180.                                                         {
  181.                                                                 if(ri==29)
  182.                                                                 ri=1;
  183.                                                         }
  184.                                                 }
  185.                                         else
  186.                                                 {
  187.                                                         if(ri==31)
  188.                                                         ri=1;
  189.                                                 }
  190.                                         write_wang1(8,ri);
  191.                                         write_com(0x80+8);
  192.                                         }
  193.                                         if(num1==5)
  194.                                         {
  195.                                         yue++;
  196.                                                 if(yue==13)
  197.                                                 {
  198.                                                 yue=1;
  199.                                                 }
  200.                                                 write_wang1(5,yue);
  201.                                         write_com(0x80+5);
  202.                                         }
  203.                                         if(num1==6)
  204.                                         {
  205.                                                          nianhou++;
  206.                                                 if(nianhou==100)
  207.                                                 {
  208.                                                 nianhou=0;                                
  209.                                                 }
  210.                                                 write_wang2(2,nianhou);
  211.                                         write_com(0x80+2);
  212.                                         }
  213.                                         if(num1==7)
  214.                                         {        nianqian++;                        
  215.                                                 if(nianqian==100)
  216.                                                 {
  217.                                                 nianqian=0;
  218.                                                 }
  219.                                                 write_wang2(0,nianqian);
  220.                                         write_com(0x80);  
  221.                                 
  222.                                         }
  223.                                         if(num1==8)
  224.                                         {
  225.                                                 xingqi++;
  226.                                                 if(xingqi==8)
  227.                                                 xingqi=1;
  228.                                                         switch(xingqi)
  229.                                                 {
  230.                                                         case 1:
  231.                                                                 write_com(0x80+13);
  232.                                                                 for(i=0;i<3;i++)
  233.                                                                 {
  234.                                                                 write_data(table2[i]);               
  235.                                                                 }
  236.                                                                 break;
  237.                                                         case 2:
  238.                                                                    write_com(0x80+13);
  239.                                                                  for(i=3;i<6;i++)
  240.                                                                 {
  241.                                                                 write_data(table2[i]);               
  242.                                                                 }
  243.                                                                 break;
  244.                                                         case 3:
  245.                                                                  write_com(0x80+13);
  246.                                                                  for(i=6;i<9;i++)
  247.                                                                 {
  248.                                                                 write_data(table2[i]);               
  249.                                                                 }
  250.                                                                 break;
  251.                                                           case 4:
  252.                                                                  write_com(0x80+13);
  253.                                                                  for(i=9;i<12;i++)
  254.                                                                 {
  255.                                                                 write_data(table2[i]);               
  256.                                                                 }
  257.                                                                 break;
  258.                                                     case 5:
  259.                                                                  write_com(0x80+13);
  260.                                                                  for(i=12;i<15;i++)
  261.                                                                 {
  262.                                                                 write_data(table2[i]);               
  263.                                                                 }
  264.                                                                 break;
  265.                                                          case 6:
  266.                                                                  write_com(0x80+13);
  267.                                                                  for(i=15;i<18;i++)
  268.                                                                 {
  269.                                                                 write_data(table2[i]);               
  270.                                                                 }
  271.                                                                 break;
  272.                                                            case 7:
  273.                                                                  write_com(0x80+13);
  274.                                                                  for(i=18;i<21;i++)
  275.                                                                 {
  276.                                                                 write_data(table2[i]);               
  277.                                                                 }
  278.                                                                 break;
  279.                                                 }

  281.                                         }
  282.                                 }
  283.                         }
  284.         if(num1!=0)
  285.                 {
  286.                  if(key3==0)
  287.                         {
  288.                                 delay(5);
  289.                                 if(key3==0)
  290.                                 {
  291.                                         while(key3!=1);
  292.                                         if(num1==1)
  293.                                         {
  294.                                         miao--;
  295.                                         if(miao==-1)
  296.                                                 {
  297.                                                 miao=59;
  298.                                                 }
  299.                                         write_wang(6,miao);
  300.                                         write_com(0x80+0x40+6);
  301.                                         }        
  302.                                         if(num1==2)
  303.                                         {
  304.                                         fen--;
  305.                                                 if(fen==-1)
  306.                                                 {
  307.                                                 fen=59;
  308.                                                 }
  309.                                         write_wang(3,fen);
  310.                                         write_com(0x80+0x40+3);
  311.                                         }
  312.                                         if(num1==3)
  313.                                         {
  314.                                         shi1--;
  315.                                                 if(shi1==-1)
  316.                                                 {
  317.                                                 shi1=23;
  318.                                                 }
  319.                                                 write_wang(0,shi1);
  320.                                         write_com(0x80+0x40);
  321.                                         }
  322.                                         if(num1==4)
  323.                                         {
  324.                                         ri--;
  325.                                         if(yue==1||yue==3||yue==5||yue==7||yue==8||yue==10||yue==12)
  326.                                         {
  327.                                                 if(ri==-1)
  328.                                                 {
  329.                                                 ri=31;
  330.                                                 }
  331.                                         }
  332.                                         else if(yue==2)
  333.                                                 {
  334.                                                         if(((nianqian*100+nianhou)%4==0 && (nianqian*100+nianhou)%100!=0 || (nianqian*100+nianhou)%400==0 ))
  335.                                                         {
  336.                                                         if(ri==-1)
  337.                                                         ri=29;
  338.                                                         }
  339.                                                         else
  340.                                                         {
  341.                                                                 if(ri==-1)
  342.                                                                 ri=28;
  343.                                                         }
  344.                                                 }
  345.                                         else
  346.                                                 {
  347.                                                         if(ri==-1)
  348.                                                         ri=30;
  349.                                                 }
  350.                                         write_wang1(8,ri);
  351.                                         write_com(0x80+8);
  352.                                         }
  353.                                         if(num1==5)
  354.                                         {
  355.                                         yue--;
  356.                                                 if(yue==0)
  357.                                                 {
  358.                                                 yue=12;
  359.                                                 }
  360.                                                 write_wang1(5,yue);
  361.                                         write_com(0x80+5);
  362.                                         }
  363.                                         if(num1==6)
  364.                                         {
  365.                                                         nianhou--;
  366.                                                 if(nianhou==-1)
  367.                                                 {
  368.                                                 nianhou=99;
  369.                                                 }
  370.                                         write_wang2(2,nianhou);
  371.                                         write_com(0x80+2);
  372.                                         }
  373.                                         if(num1==7)
  374.                                         {
  375.                                                  nianqian--;
  376.                                                 if(nianqian==-1)
  377.                                                 {
  378.                                                 nianqian=99;
  379.                                                 }
  380.                                          write_wang2(0,nianqian);
  381.                                         write_com(0x80);
  382.                                         }
  383.                                         if(num1==8)
  384.                                         {
  385.                                                 xingqi--;
  386.                                                 if(xingqi==0)
  387.                                                 xingqi=7;
  388.                                                         switch(xingqi)
  389.                                                 {
  390.                                                         case 1:
  391.                                                                 write_com(0x80+13);
  392.                                                                 for(i=0;i<3;i++)
  393.                                                                 {
  394.                                                                 write_data(table2[i]);               
  395.                                                                 }
  396.                                                                 break;
  397.                                                         case 2:
  398.                                                                    write_com(0x80+13);
  399.                                                                  for(i=3;i<6;i++)
  400.                                                                 {
  401.                                                                 write_data(table2[i]);               
  402.                                                                 }
  403.                                                                 break;
  404.                                                         case 3:
  405.                                                                  write_com(0x80+13);
  406.                                                                  for(i=6;i<9;i++)
  407.                                                                 {
  408.                                                                 write_data(table2[i]);               
  409.                                                                 }
  410.                                                                 break;
  411.                                                           case 4:
  412.                                                                  write_com(0x80+13);
  413.                                                                  for(i=9;i<12;i++)
  414.                                                                 {
  415.                                                                 write_data(table2[i]);               
  416.                                                                 }
  417.                                                                 break;
  418.                                                     case 5:
  419.                                                                  write_com(0x80+13);
  420.                                                                  for(i=12;i<15;i++)
  421.                                                                 {
  422.                                                                 write_data(table2[i]);               
  423.                                                                 }
  424.                                                                 break;
  425.                                                          case 6:
  426.                                                                  write_com(0x80+13);
  427.                                                                  for(i=15;i<18;i++)
  428.                                                                 {
  429.                                                                 write_data(table2[i]);               
  430.                                                                 }
  431.                                                                 break;
  432.                                                            case 7:
  433.                                                                  write_com(0x80+13);
  434.                                                                  for(i=18;i<21;i++)
  435.                                                                 {
  436.                                                                 write_data(table2[i]);               
  437.                                                                 }
  438.                                                                 break;
  439.                                                 }

  441.                                         }
  442.                                 }
  443.                         }
  444.                 }
  445. }        
  446. }

  448. void duxianshi()
  449. {
  450.                 write_com(0x80);
  451.                 for(num=0;num<10;num++)
  452.                 {
  453.                 write_data(table[num]);
  454.                 delay(5);
  455.                 }
  456.                 write_com(0x80+13);
  457.                 for(num=0;num<3;num++)
  458.                 {
  459.                         write_data(table2[num]);
  460.                         delay(5);        
  461.                 }
  462.                 write_com(0x80+0x40);
  463.                 for(num=0;num<8;num++)
  464.                 {
  465.                         write_data(table1[num]);
  466.                         delay(5);
  467.                 }
  468. }
  469. void time()
  470. {
  471.         uchar i;
  472.                         if(num==18)
  473.                                 {
  474.                                         num=0;
  475.                                         miao++;
  476.                                         if(miao==60)
  477.                                     {
  478.                                                                 miao=0;
  479.                                                                 fen++;
  480.                                                                 if(fen==60)
  481.                                                                 {
  482.                                                                         fen=0;
  483.                                                                         shi1++;
  484.                                                                                 if(shi1==24)
  485.                                                                                         {
  486.                                                                                                 shi1=0;
  487.                                                                                                 ri++;
  488.                                                                                                 xingqi++;
  489.                                                                                                 if(xingqi==8)
  490.                                                                                                 xingqi=1;
  491.                                                                                                 switch(xingqi)
  492.                                                                                                 {
  493.                                                                                                         case 1:
  494.                                                                                                         write_com(0x80+13);
  495.                                                                                                         for(i=0;i<3;i++)
  496.                                                                                                         {
  497.                                                                                                         write_data(table2[i]);               
  498.                                                                                                         }
  499.                                                                                                         break;
  500.                                                                                                         case 2:
  501.                                                                                                            write_com(0x80+13);
  502.                                                                                                          for(i=3;i<6;i++)
  503.                                                                                                         {
  504.                                                                                                         write_data(table2[i]);               
  505.                                                                                                         }
  506.                                                                                                         break;
  507.                                                                                                         case 3:
  508.                                                                                                          write_com(0x80+13);
  509.                                                                                                          for(i=6;i<9;i++)
  510.                                                                                                         {
  511.                                                                                                         write_data(table2[i]);               
  512.                                                                                                         }
  513.                                                                                                         break;
  514.                                                                                                           case 4:
  515.                                                                                                          write_com(0x80+13);
  516.                                                                                                          for(i=9;i<12;i++)
  517.                                                                                                         {
  518.                                                                                                         write_data(table2[i]);               
  519.                                                                                                         }
  520.                                                                                                         break;
  521.                                                                                                     case 5:
  522.                                                                                                          write_com(0x80+13);
  523.                                                                                                          for(i=12;i<15;i++)
  524.                                                                                                         {
  525.                                                                                                         write_data(table2[i]);               
  526.                                                                                                         }
  527.                                                                                                         break;
  528.                                                                                                          case 6:
  529.                                                                                                          write_com(0x80+13);
  530.                                                                                                          for(i=15;i<18;i++)
  531.                                                                                                         {
  532.                                                                                                         write_data(table2[i]);               
  533.                                                                                                         }
  534.                                                                                                         break;
  535.                                                                                                            case 7:
  536.                                                                                                          write_com(0x80+13);
  537.                                                                                                          for(i=18;i<21;i++)
  538.                                                                                                         {
  539.                                                                                                         write_data(table2[i]);               
  540.                                                                                                         }
  541.                                                                                                         break;
  542.                                                                                                 }
  543.                                                                                                         if(yue==1||yue==3||yue==5||yue==7||yue==8||yue==10||yue==12)
  544.                                                                                                         {
  545.                                                                                                                         if(ri==32)
  546.                                                                                                                         {
  547.                                                                                                                                 ri=1;
  548.                                                                                                                                 yue++;
  549.                                                                                                                                 if(yue==13)
  550.                                                                                                                                 {
  551.                                                                                                                                         yue=1;
  552.                                                                                                                                         nianhou++;
  553.                                                                                                                                         if(nianhou==100)
  554.                                                                                                                                         {
  555.                                                                                                                                                 nianhou=0;
  556.                                                                                                                                                 nianqian++;
  557.                                                                                                                                                 if(nianqian==100)
  558.                                                                                                                                                 {
  559.                                                                                                                                                      nianqian=0;
  560.                                                                                                                                                          nianhou=0;
  561.                                                                                                                                                          yue=0;
  562.                                                                                                                                                          ri=0;
  563.                                                                                                                                                          shi1=0;
  564.                                                                                                                                                          fen=0;
  565.                                                                                                                                                          miao=0;
  566.                                                                                                                                                         write_com(0x80+13);
  567.                                                                                                                                                         for(i=0;i<3;i++)
  568.                                                                                                                                                         {
  569.                                                                                                                                                         write_data(table2[i]);               
  570.                                                                                                                                                         }
  571.                                                                                                                                                 }
  572.                                                                                                                                                    write_wang2(0,nianqian);        
  573.                                                                                                                                         }
  574.                                                                                                                                 write_wang2(2,nianhou);               
  575.                                                                                                                         }
  576.                                                                                                                         write_wang1(5,yue);
  577.                                                                                                                 }
  578.                                                                                                                         write_wang1(8,ri);
  579.                                                                                                         }
  580.                                                                                                         else if(yue==2)
  581.                                                                                                         {
  582.                                                                                                                 if(ri==29)
  583.                                                                                                                         {
  584.                                                                                                                                 ri=1;
  585.                                                                                                                                 yue++;
  586.                                                                                                                                 if(yue==13)
  587.                                                                                                                                 {
  588.                                                                                                                                         yue=1;
  589.                                                                                                                                         nianhou++;
  590.                                                                                                                                         if(nianhou==100)
  591.                                                                                                                                         {
  592.                                                                                                                                                 nianhou=0;
  593.                                                                                                                                                 nianqian++;
  594.                                                                                                                                                 if(nianqian==100)
  595.                                                                                                                                                 {
  596.                                                                                                                                                      nianqian=0;
  597.                                                                                                                                                          nianhou=0;
  598.                                                                                                                                                          yue=0;
  599.                                                                                                                                                          ri=0;
  600.                                                                                                                                                          shi1=0;
  601.                                                                                                                                                          fen=0;
  602.                                                                                                                                                          miao=0;
  603.                                                                                                                                                         write_com(0x80+13);
  604.                                                                                                                                                         for(i=0;i<3;i++)
  605.                                                                                                                                                         {
  606.                                                                                                                                                         write_data(table2[i]);               
  607.                                                                                                                                                         }
  608.                                                                                                                                                 }
  609.                                                                                                                                                    write_wang2(0,nianqian);        
  610.                                                                                                                                         }
  611.                                                                                                                                 write_wang2(2,nianhou);               
  612.                                                                                                                         }
  613.                                                                                                                         write_wang1(5,yue);
  614.                                                                                                                 }
  615.                                                                                                                         write_wang1(8,ri);
  616.                                                                                                         }
  617.                                                                                                         else
  618.                                                                                                         {
  619.                                                                                                                  if(ri==31)
  620.                                                                                                                         {
  621.                                                                                                                                 ri=1;
  622.                                                                                                                                 yue++;
  623.                                                                                                                                 if(yue==13)
  624.                                                                                                                                 {
  625.                                                                                                                                         yue=1;
  626.                                                                                                                                         nianhou++;
  627.                                                                                                                                         if(nianhou==100)
  628.                                                                                                                                         {
  629.                                                                                                                                                 nianhou=0;
  630.                                                                                                                                                 nianqian++;
  631.                                                                                                                                                 if(nianqian==100)
  632.                                                                                                                                                 {
  633.                                                                                                                                                      nianqian=0;
  634.                                                                                                                                                          nianhou=0;
  635.                                                                                                                                                          yue=0;
  636.                                                                                                                                                          ri=0;
  637.                                                                                                                                                          shi1=0;
  638.                                                                                                                                                          fen=0;
  639.                                                                                                                                                          miao=0;
  640.                                                                                                                                                         write_com(0x80+13);
  641.                                                                                                                                                         for(i=0;i<3;i++)
  642.                                                                                                                                                         {
  643.                                                                                                                                                         write_data(table2[i]);               
  644.                                                                                                                                                         }
  645.                                                                                                                                                 }
  646.                                                                                                                                                    write_wang2(0,nianqian);        
  647.                                                                                                                                         }
  648.                                                                                                                                 write_wang2(2,nianhou);               
  649.                                                                                                                         }
  650.                                                                                                                         write_wang1(5,yue);
  651.                                                                                                                 }
  652.                                                                                                                         write_wang1(8,ri);
  653.                                                                                                         }
  654.                                                                                         }
  655.                                                                          write_wang(0,shi1);
  656.                                 }                                         
  657.                                 write_wang(3,fen);
  658.         }
  659.         write_wang(6,miao);
  660. }               
  661. }
  662. void main()
  663. {        
  664.     EA=1;
  665.         ET0=1;
  666.         TMOD=0X01;
  667.         TH0=(65536-50000)/256;
  668.         TL0=(65536-50000)%256;        
  669.         init();
  670.         duxianshi();
  671.         num=0;
  672.         TR0=1;        
  673.                 while(1)
  674.                 {        

  676.                            time();
  677.                         keycan();
  678. }
  679. }
  680. void T0_time()interrupt 1
  681. {
  682.         TH0=(65536-50000)/256;
  683.         TL0=(65536-50000)%256;
  684.         num++;
  685. }
復(fù)制代碼



作者: abclv    時(shí)間: 2017-6-14 09:50
大神在嘛



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1