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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 单片机学习：时钟功能加计数功能显示源码
返回列表 发新帖
查看: 1148|回复: 2
打印 上一主题 下一主题
收起左侧

单片机学习：时钟功能加计数功能显示源码

[复制链接]
跳转到指定楼层
楼主
ID:629448 发表于 2019-11-27 08:33 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
本帖最后由 冇妖气 于 2019-12-23 10:33 编辑

初学单片机，用的是慧净电子的HL-1开发板，七拼八凑的组成了通过LCD1602显示时间及工作计数功能，按键可以实现屏幕内容切换。源码分享给大家一起讨论优化。界面显示注释： JS： 累计工作次数； CS ：单次排量常数（可以通过按键设置）；PL：累计排量总数(等于JS*CS)。
按键注释： S1：设置按键，时间显示界面可以设置时分秒，年月日，计数功能界面可以设置单次排量常数CS；
                 S2：数值加键，设置界面可以对对应位置数值进行加操作；
                 S3：数值减键，设置界面可以对对应位置数值进行减操作；
                 S4:显示界面切换按键，在时间显示和工作计数界面来回切换；
                 S5：模拟工作状态下的阀门开关信号。接收一次低电平信号，计数一次。
代码如下：
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #define uchar unsigned char
  4. #define uint unsigned int

  6. // 定义4个键盘按键
  7. sbit s1=P3^0; //功能键
  8. sbit s2=P3^1; //加键
  9. sbit s3=P3^2; //减键
  10. sbit s4=P3^3; //显示切换键
  11. sbit s5=P3^6; //模拟信号键
  12. sbit rd=P3^7;

  14. sbit dula=P2^6;
  15. sbit wela=P2^7;

  17. sbit lcden=P2^2;
  18. sbit rs=P2^0;
  19. sbit rw=P2^1;




  24. // DS1302操作
  25. sbit sclk=P1^1;          //串行时钟
  26. sbit IO=P1^0;  //数据输入输出
  27. sbit rst=P1^2;         //复位脚

  29. uchar s1num,s2num,s3num;           //s1num时钟功能调整，flag1时钟调整状态标志，count工作次数，counts排水量，s2num设置切换屏幕，s3num设置常数
  30. int miao,shi,fen,nian,yue,ri,week;
  31. int x1,x2,x3;
  32. unsigned long count;
  33. unsigned long counts;
  34. x3=0;
  35. /*//星期字表
  36. uchar code table1[]="SUN";
  37. uchar code table2[]="MON";
  38. uchar code table3[]="TUE";
  39. uchar code table4[]="WED";
  40. uchar code table5[]="THU";
  41. uchar code table6[]="FRI";
  42. uchar code table7[]="SAT";
  43. */
  44. //延时函数
  45. void delayms(uint z)
  46. {
  47.         uint x,y;
  48.         for(x=z;x>0;x--)
  49.                 for(y=110;y>0;y--);
  50. }
  51. //关闭数码管函数
  52. void cmg88()
  53. {
  54.         dula=1;
  55.         P0=0x00;
  56.         dula=0;
  57. }

  59. //液晶写命令函数
  60. void write_com(uchar com)
  61. {
  62.         rs=0;
  63.         lcden=0;
  64.         P0=com;
  65.         delayms(5);
  66.         lcden=1;
  67.         delayms(5);
  68.         lcden=0;
  69. }

  71. //液晶写数据函数
  72. void write_date(uchar date)
  73. {
  74.         rs=1;
  75.         lcden=0;
  76.         P0=date;
  77.         delayms(5);
  78.         lcden=1;
  79.         delayms(5);
  80.         lcden=0;
  81. }

  83. //向1302写一个字节数据
  84. void write1302(uchar dat)
  85. {
  86.         uchar i;
  87.         for(i=0;i<8;i++)
  88.                 {       
  89.                         sclk=0;
  90.                         IO=dat&0x01;
  91.                         dat=dat>>1;
  92.                         sclk=1;
  93.                 }
  94. }

  96. //根据命令，向1302写一个字节数据
  97. void writeset1302(uchar cmd,uchar dat)
  98. {
  99.         rst=0;
  100.         _nop_();
  101.         sclk=0;
  102.         _nop_();
  103.         rst=1;
  104.         _nop_();
  105.         write1302(cmd);
  106.         write1302(dat);
  107.         sclk=1;
  108.         rst=0;
  109.         IO=1;
  110. }

  112. //向1302读一个字节数据
  113. uchar read1302(uchar cmd)
  114. {
  115.         uchar i,value;
  116.        
  117.         rst=0;
  118.         _nop_();
  119.         sclk=0;
  120.         _nop_();
  121.         rst=1;
  122.         _nop_();
  123.         write1302(cmd);
  124.         for(i=0;i<8;i++)
  125.         {
  126.                 value=value>>1;
  127.                 sclk=0;
  128.                 if(IO)
  129.                 value=value|0x80;
  130.                 sclk=1;
  131.                 }
  132.                 rst=0;
  133.                 sclk=0;
  134.                 _nop_();
  135.                 sclk=1;
  136.                 IO=1;
  137.        
  138.         return value;
  139. }

  141. //根据命令向1302读一个字节数据
  142. uchar readset1302(uchar cmd)
  143. {
  144.         uchar dat;
  145.         rst=0;
  146.         sclk=0;
  147.         rst=1;
  148.         write1302(cmd);
  149.         dat=read1302(cmd);
  150.         sclk=1;
  151.         rst=0;
  152.         return(dat);
  153. }

  155. // 初始化1302
  156. void init1302()
  157. {
  158. //        unsigned char flag;
  159.    
  160. //   flag= readset1302(0x81);
  161. //        if(flag&0x80)       
  162. //        {      //判断时钟芯片是否关闭
  163.      writeset1302(0x8E,0x00);                 //根据写状态寄存器命令字，写入不保护指令
  164.            writeset1302(0x80,0x56);   //根据写秒寄存器命令字，写入秒的初始值
  165.         writeset1302(0x82,0x59);   //根据写分寄存器命令字，写入分的初始值
  166.         writeset1302(0x84,0x23); //根据写小时寄存器命令字，写入小时的初始值
  167.         writeset1302(0x86,0x31); //根据写日寄存器命令字，写入日的初始值
  168.         writeset1302(0x88,0x12); //根据写月寄存器命令字，写入月的初始值
  169.         writeset1302(0x8c,0x18);  //根据写年寄存器命令字，写入年的初始值
  170.         writeset1302(0x90,0xa5);                //打开充电功能 选择2K电阻充电方式
  171.         writeset1302(0x8E,0x80);                           //根据写状态寄存器命令字，写入保护指令
  172. //        }
  173. }         
  174. //时分秒函数
  175. void write_sfm(uchar add,uchar dat)
  176. {
  177.         uchar gw,sw;
  178.         gw=dat%16;
  179.         sw=dat/16;
  180.         write_com(0x80+0x40+add);
  181.         write_date(0x30+sw);
  182.         write_date(0x30+gw);
  183. }

  185. //年月日函数
  186. void write_nyr(uchar add,uchar dat)
  187. {
  188.         uchar gw,sw;
  189.         gw=dat%16;
  190.         sw=dat/16;
  191.         write_com(0x80+add);
  192.         write_date(0x30+sw);
  193.         write_date(0x30+gw);
  194. }

  196. //星期函数
  197. /*void write_week(uchar xq)
  198. {
  199.         uchar x;
  200.         write_com(0x80+12);
  201.         switch(xq)
  202.         {
  203.                 case 1:
  204.                         for(x=0;x<3;x++)
  205.                         {
  206.                                 write_date(table1[x]);
  207.                         }
  208.                         break;
  209.                 case 2:
  210.                         for(x=0;x<3;x++)
  211.                         {
  212.                                 write_date(table2[x]);
  213.                         }
  214.                         break;
  215.                 case 3:
  216.                         for(x=0;x<3;x++)
  217.                         {
  218.                                 write_date(table3[x]);
  219.                         }
  220.                         break;
  221.                 case 4:
  222.                         for(x=0;x<3;x++)
  223.                         {
  224.                                 write_date(table4[x]);
  225.                         }
  226.                         break;
  227.                 case 5:
  228.                         for(x=0;x<3;x++)
  229.                         {
  230.                                 write_date(table5[x]);
  231.                         }
  232.                         break;
  233.                 case 6:
  234.                         for(x=0;x<3;x++)
  235.                         {
  236.                                 write_date(table6[x]);
  237.                         }
  238.                         break;
  239.                 case 7:
  240.                         for(x=0;x<3;x++)
  241.                         {
  242.                                 write_date(table7[x]);
  243.                         }
  244.                         break;
  245.         }
  246.                 write_com(0x80+12);
  247. } */
  248. //写计工作次数函数
  249. void write_JS(uchar add,unsigned long dat)
  250. {
  251.         uchar x,y,z,j,k;
  252.         x=dat/10000;
  253.         y=(dat%10000)/1000;
  254.         z=(dat%1000)/100;
  255.         j=(dat%100)/10;
  256.         k=dat%10;
  257.         write_com(0x80+add);
  258.         write_date(0x30+x);
  259.         write_date(0x30+y);
  260.         write_date(0x30+z);
  261.         write_date(0x30+j);
  262.         write_date(0x30+k);       
  263. }
  264. //写单次排量函数
  265. void write_CS(uchar add,uchar dat)
  266. {
  267.         uchar gw,sw;
  268.         gw=dat%10;
  269.         sw=dat/10;
  270.         write_com(0x80+add);
  271.         write_date(0x30+sw);
  272.         write_date(0x30+gw);       
  273. }
  274. //写总排量函数
  275. void write_PL(uchar add,unsigned long dat)
  276. {
  277.         uchar x,y,z,j,k;
  278. //        a=dat/1000000;
  279. //        b=(dat%1000000)/100000;
  280.         x=(dat%100000)/10000;
  281.         y=(dat%10000)/1000;
  282.         z=(dat%1000)/100;
  283.         j=(dat%100)/10;
  284.         k=dat%10;
  285.         write_com(0x80+0x40+add);
  286. //        write_date(0x30+a);
  287. //        write_date(0x30+b);
  288.         write_date(0x30+x);
  289.         write_date(0x30+y);
  290.         write_date(0x30+z);
  291.         write_date(0x30+j);
  292.         write_date(0x30+k);       
  293. }
  294. //液晶初始化
  295. void init()
  296. {
  297.        
  298.         rd=0;
  299.         dula=0;
  300.         wela=0;
  301.         rw=0;
  302.         lcden=0;
  303.         miao=0;
  304.         fen=0;
  305.         shi=0;
  306.         week=1;
  307.         nian=0;
  308.         yue=0;
  309.         ri=0;
  310.         s1num=0;
  311.         s2num=0;

  313.         write_com(0x38);
  314.         write_com(0x0c);
  315.         write_com(0x06);
  316.         write_com(0x01);

  318.         write_com(0x80+1);//年份前两位固定显示20
  319.         write_date('2');
  320.         write_date('0');
  321.         delayms(5);

  323.         write_com(0x80+5);
  324.         write_date('-');
  325.         delayms(5);
  326.         write_com(0x80+8);
  327.         write_date('-');
  328.         delayms(5);

  330.         write_com(0x80+0x40+4);
  331.         write_date(':');
  332.         delayms(5);
  333.         write_com(0x80+0x40+7);
  334.         write_date(':');
  335.         delayms(5);
  336. }

  338. //键盘设置操作
  339. void keyscan()
  340. {
  341.         if(s1==0&&s2num==0) //时钟调整功能键,并且不处于计数界面
  342.         {
  343.         delayms(5);
  344.         if(s1==0&&s2num==0)
  345.         {
  346.                 s1num++;
  347.                
  348.                 while(!s1);
  349.                 switch(s1num)
  350.                 {
  351.                         case 1:
  352.                         write_com(0x80+0x40+9);
  353.                         write_com(0x0f);
  354.                         break;
  355.                        
  356.                         case 2:
  357.                         write_com(0x80+0x40+6);
  358.                         break;

  360.                         case 3:
  361.                         write_com(0x80+0x40+3);
  362.                         break;

  364.                         case 4:
  365.                         write_com(0x80+14);
  366.                         break;

  368.                         case 5:
  369.                         write_com(0x80+10);
  370.                         break;

  372.                         case 6:
  373.                         write_com(0x80+7);
  374.                         break;

  376.                         case 7:
  377.                         write_com(0x80+4);
  378.                         break;

  380.                         case 8:                       
  381.                         s1num=0;
  382.                         writeset1302(0x8e,0x00);//功能键停止后，将设置的当前值存入1302
  383.                         writeset1302(0x80,miao);
  384.                         writeset1302(0x82,fen);
  385.                         writeset1302(0x84,shi);
  386.                 //        writeset1302(0x8a,week);
  387.                         writeset1302(0x86,ri);
  388.                         writeset1302(0x88,yue);
  389.                         writeset1302(0x8c,nian);
  390.                         writeset1302(0x8e,0x80);
  391.                         write_com(0x0c);
  392.                         break;
  393.                 }
  394.         }
  395.         }       
  396.         if(s1num!=0&&s2num==0)  
  397.         {
  398.                 if(s2==0)        //设置加键
  399.                 {
  400.                 delayms(5);
  401.                 if(s2==0)
  402.                 {
  403.                         while(!s2);
  404.                         switch(s1num)
  405.                         {
  406.                                 case 1:
  407.                                 x1=miao%16;
  408.                                 x2=miao/16;
  409.                                 x1++;
  410.                                 if(x1==10)
  411.                                 {
  412.                                         x1=0;
  413.                                         x2++;
  414.                                         if(x2>=6)
  415.                                         x2=0;
  416.                                 }
  417.                                 miao=x1+x2*16;
  418.                                 write_sfm(8,miao);
  419.                                 write_com(0x80+0x40+9);
  420.                                 break;

  422.                                 case 2:
  423.                                 x1=fen%16;
  424.                                 x2=fen/16;
  425.                                 x1++;
  426.                                 if(x1==10)
  427.                                 {
  428.                                         x1=0;
  429.                                         x2++;
  430.                                         if(x2>=6)
  431.                                         x2=0;
  432.                                 }
  433.                                 fen=x1+x2*16;
  434.                                 write_sfm(5,fen);
  435.                                 write_com(0x80+0x40+6);
  436.                                 break;

  438.                                 case 3:
  439.                                 x1=shi%16;
  440.                                 x2=shi/16;
  441.                                 x1++;
  442.                                 if(x1==10)
  443.                                 {
  444.                                         x1=0;
  445.                                         x2++;
  446.                                 }
  447.                                         if(x2>=2&&x1>=4)
  448.                                         {
  449.                                         x1=0;
  450.                                         x2=0;
  451.                                         }
  452.                                 shi=x1+x2*16;
  453.                                 write_sfm(2,shi);
  454.                                 write_com(0x80+0x40+3);
  455.                                 break;

  457.                                 case 4:
  458.                                 x1=week%10;
  459.                                 x2=week/10;
  460.                                 x1++;
  461.                                 if(x1==8)
  462.                                 x1=1;
  463.                                 week=x2*10+x1;
  464.                         //        write_week(week);
  465.                         //        write_com(0x80+14);
  466.                                 break;               

  468.                                 case 5:
  469.                                 x1=ri%16;
  470.                                 x2=ri/16;
  471.                                 x1++;
  472.                                 if(x1==10)
  473.                                 {
  474.                                         x1=0;
  475.                                         x2++;
  476.                                 }
  477.                                         if(x2==3&&x1==2)
  478.                                          {
  479.                                         x2=0;
  480.                                         x1=0;
  481.                                         }
  482.                                 ri=x1+x2*16;
  483.                                 write_nyr(9,ri);
  484.                                 write_com(0x80+10);
  485.                                 break;

  487.                                 case 6:
  488.                                 x1=yue%16;
  489.                                 x2=yue/16;
  490.                                 x1++;
  491.                                 if(x2==1&&x1==3)
  492.                                 {
  493.                                         x1=1;
  494.                                         x2=0;
  495.                                 }
  496.                                 if(x1==10)
  497.                                 {
  498.                                         x1=0;
  499.                                         x2++;
  500.                                 }
  501.                                 yue=x1+x2*16;
  502.                                 write_nyr(6,yue);
  503.                                 write_com(0x80+7);
  504.                                 break;

  506.                                 case 7:
  507.                                 x1=nian%16;
  508.                                 x2=nian/16;
  509.                                 x1++;
  510.                                 if((x2==9)&&(x1==10))
  511.                                 {
  512.                                         x1=0;
  513.                                         x2=0;
  514.                                 }
  515.                                 if(x1==10)
  516.                                 {
  517.                                         x2++;
  518.                                         x1=0;
  519.                                 }
  520.                                 nian=x1+x2*16;
  521.                                 write_nyr(3,nian);
  522.                                 write_com(0x80+4);
  523.                                 break;
  524.                         }
  525.                 }
  526.                 }

  528.                 if(s3==0&&s2num==0)
  529.                 {                                                                                                                                                                                                                                                                                                         
  530.                 delayms(5);
  531.                 if(s3==0&&s2num==0)
  532.                 {
  533.                         while(!s3);
  534.                         switch(s1num)
  535.                         {
  536.                                 case 1:
  537.                                 x1=miao%16;
  538.                                 x2=miao/16;
  539.                                 x1--;
  540.                                 if(x1==-1)
  541.                                 {
  542.                                 x1=9;
  543.                                 x2--;
  544.                                 if(x2==-1)
  545.                                 x2=5;
  546.                                 }
  547.                                 miao=x1+x2*16;
  548.                                 write_sfm(8,miao);
  549.                                 write_com(0x80+0x40+9);
  550.                                 break;

  552.                                 case 2:
  553.                                 x1=fen%16;
  554.                                 x2=fen/16;
  555.                                 x1--;
  556.                                 if(x1==-1)
  557.                                 {
  558.                                 x1=9;
  559.                                 x2--;
  560.                                 if(x2==-1)
  561.                                 x2=5;
  562.                                 }
  563.                                 fen=x1+x2*16;
  564.                                 write_sfm(5,fen);
  565.                                 write_com(0x80+0x40+6);
  566.                                 break;

  568.                                 case 3:
  569.                                 x1=shi%16;
  570.                                 x2=shi/16;
  571.                                 x1--;
  572.                                 if(x1==-1)
  573.                                 {
  574.                                 x1=9;
  575.                                 x2--;
  576.                                 if(x2==-1)
  577.                                 {
  578.                                 x2=2;
  579.                                 x1=3;
  580.                                 }
  581.                                 }
  582.                                 shi=x1+x2*16;
  583.                                 write_sfm(2,shi);
  584.                                 write_com(0x80+0x40+3);
  585.                                 break;

  587.                                 case 4:
  588.                                 x1=(week)%16;
  589.                                 x2=(week)/16;
  590.                                 x1--;
  591.                                 if(x1==0)
  592.                                 x1=7;
  593.                                 week=x1+x2*16;
  594.                         //        write_week(week);
  595.                         //        write_com(0x80+14);
  596.                                 break;         

  598.                                 case 5:
  599.                                 x1=ri%16;
  600.                                 x2=ri/16;
  601.                                 x1--;
  602.                                 if(x1==-1)
  603.                                 {
  604.                                         x1=9;
  605.                                         x2--;
  606.                                         if(x2==-1)
  607.                                         {
  608.                                         x1=1;
  609.                                         x2=3;
  610.                                         }
  611.                                 }
  612.                                 ri=x1+x2*16;
  613.                                 write_nyr(9,ri);
  614.                                 write_com(0x80+10);
  615.                                 break;

  617.                                 case 6:
  618.                                 x1=yue%16;
  619.                                 x2=yue/16;
  620.                                 x1--;
  621.                                 if((x2==1)&&(x1==-1))
  622.                                 {
  623.                                         x1=9;
  624.                                         x2--;
  625.                                 }
  626.                                 if((x2==0)&&(x1==0))
  627.                                 {
  628.                                         x1=2;
  629.                                         x2=1;
  630.                                 }
  631.                                 yue=x1+x2*16;
  632.                                 write_nyr(6,yue);
  633.                                 write_com(0x80+7);
  634.                                 break;

  636.                                 case 7:
  637.                                 x1=nian%16;
  638.                                 x2=nian/16;
  639.                                 x1--;
  640.                                 if(x1==-1)
  641.                                 {
  642.                                         x1=9;
  643.                                         x2--;
  644.                                         if(x2==-1)
  645.                                         {
  646.                                                 x1=9;
  647.                                                 x2=9;
  648.                                         }
  649.                                 }
  650.                                 nian=x1+x2*16;
  651.                                 write_nyr(3,nian);
  652.                                 write_com(0x80+4);
  653.                                 break;
  654.                         }
  655.                 }
  656.                 }
  657.         }         

  659.                 if(s3num==0&&s1num==0)        //切换屏幕
  660.                 {
  661.                 if(s4==0)
  662.                 {
  663.                 delayms(5);
  664.                 if(s4==0)
  665.                 {  
  666.                 s2num++;
  667.                 while(!s4)                               
  668.                 {                       
  669.                 if(s2num==1)
  670.                 {
  671.                 write_com(0x01);
  672.                 write_com(0x80);
  673.                 write_date('J');
  674.                 write_com(0x80+1);
  675.                 write_date('S');
  676.                 write_com(0x80+2);
  677.                 write_date(':');
  678.                 write_com(0x80+4);
  679.                 write_JS(3,count);
  680.                
  681.                
  682.                
  683.                 write_com(0x80+11);
  684.                 write_date('C');
  685.                 write_com(0x80+12);
  686.                  write_date('S');
  687.                 write_com(0x80+13);
  688.                 write_date(':');
  689.                 write_CS(14,x3);

  691.                 write_com(0x80+0x40);
  692.                 write_date('P');
  693.                 write_com(0x80+0x40+1);
  694.                 write_date('L');
  695.                 write_com(0x80+0x40+2);
  696.                 write_date(':');
  697.                 counts=count*x3;
  698.                 write_PL(3,counts);               
  699.                 }
  700.                 if(s2num==2)
  701.                 {
  702.                         s2num=0;
  703.                         write_com(0x01);
  704.                         write_com(0x80+1);//年份前两位固定显示20
  705.                         write_date('2');
  706.                         write_date('0');
  707.                         delayms(5);
  708.                
  709.                         write_com(0x80+5);
  710.                         write_date('-');
  711.                         delayms(5);
  712.                         write_com(0x80+8);
  713.                         write_date('-');
  714.                         delayms(5);
  715.                
  716.                         write_com(0x80+0x40+4);
  717.                         write_date(':');
  718.                         delayms(5);
  719.                         write_com(0x80+0x40+7);
  720.                         write_date(':');
  721.                         delayms(5);
  722.                 }
  723.                 }
  724.                 }
  725.                 }
  726.                 }
  727.                 if(s2num==1&&s1num==0)
  728.                 {
  729.                         if(s1==0)
  730.                         {
  731.                                 delayms(5);
  732.                                 if(s1==0)
  733.                                 {
  734.                                         s3num++;
  735.                                         while(!s1)
  736.                                         switch(s3num)
  737.                                         {
  738.                                                 case 1: write_com(0x80+15);
  739.                                                                 write_com(0x0f);
  740.                                                                 break;
  741.                                                 case 2: s3num=0;
  742.                                                                 write_com(0x0c);
  743.                                                                 writeset1302(0x8e,0x00);
  744.                                                                 writeset1302(0xc0,x3);
  745.                                                                 writeset1302(0x8e,0x80);
  746.                                                                 break;                                                                               
  747.                                                 }
  748.                                          }
  749.                         }
  750.                                
  751.                         if(s3num!=0)
  752.                         {
  753.                                 if(s2==0)
  754.                                 {
  755.                                         delayms(100);
  756.                                         if(s2==0)
  757.                                         {       
  758.                                
  759.                                                 x3++;
  760.                                                 _nop_();
  761.                                                 if(x3==99)
  762.                                                 x3=0;
  763.                                        
  764.                                         }
  765.                                                 write_CS(14,x3);
  766.                                         write_com(0x80+15);
  767.                                         }
  768.                                 if(s3==0)
  769.                                 {
  770.                                         delayms(100);
  771.                                         if(s3==0)
  772.                                         {
  773.                                                 x3--;
  774.                                                 _nop_();
  775.                                                 if(x3==-1)
  776.                                                 x3=99;
  777.                                         }
  778.                                                 write_CS(14,x3);
  779.                                                 write_com(0x80+15);
  780.                                         }
  781.                                 }
  782.                                 }
  783.                 /*                if(s3num==0)
  784.                                 {               
  785.                                 if(s5==0)
  786.                                 {
  787.                                 delayms(100);
  788.                                 if(s5==0)
  789.                                 {
  790.                                 while(!s5)
  791.                                 {
  792.                                 count=count+1;
  793.                             counts=count*x3;
  794.                                  if(s2num==1&&s3num==0)
  795.                                  {
  796.                                 write_JS(3,count);
  797.                                 write_PL(3,counts);
  798.                                 }
  799.                                 }
  800.                         }
  801.                         }
  802.                         }*/
  803.                
  804.                    if(s5==0)
  805.                         {
  806.                         delayms(100);
  807.                         if(s5==0)
  808.                         {
  809.                                 while(!s5)
  810.                                 {
  811.                                 count=count+1;
  812.                                 counts=count*x3;
  813.                                          if(s2num==1&&s3num==0)
  814.                                  {
  815.                                 write_JS(3,count);
  816.                                 write_PL(3,counts);
  817.                                 }
  818.                                 }
  819.                                    }
  820.                         }
  821.         }
  822.        

  824. void main()
  825. {
  826.        
  827.         cmg88();
  828.         init();       
  829.         init1302();
  830.         while(1)
  831.         {
  832.                 keyscan();
  833.                 if(s1num==0&&s2num==0)
  834.                 {
  835.                         miao=readset1302(0x81);
  836.                         fen=readset1302(0x83);
  837.                         shi=readset1302(0x85);
  838.                         ri=readset1302(0x87);
  839.                         yue=readset1302(0x89);
  840.                         nian=readset1302(0x8d);
  841.                         week=readset1302(0x8b);
  842.                         write_sfm(8,miao);
  843.                         write_sfm(5,fen);
  844.                         write_sfm(2,shi);
  845.                         write_nyr(9,ri);
  846.                         write_nyr(6,yue);
  847.                         write_nyr(3,nian);
  848. //                        write_week(week);
  849.                 }
  850.         }
  851. }
复制代码





1302时钟+1602+键盘.rar

101.51 KB, 下载次数: 2, 下载积分: 黑币 -5

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

使用道具 举报

沙发
ID:1 发表于 2019-11-27 12:23 | 只看该作者
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)
回复

使用道具 举报

板凳
ID:629448 发表于 2019-11-29 14:03 | 只看该作者
admin 发表于 2019-11-27 12:23
本帖需要重新编辑补全电路原理图,源码,详细说明与图片即可获得100+黑币(帖子下方有编辑按钮)

新手学习，用的HL-1的开发板，没有电路原理图
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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