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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › stc12单片机多功能数字电表程序
返回列表 发新帖
查看: 1133|回复: 2
打印 上一主题 下一主题
收起左侧

stc12单片机多功能数字电表程序

[复制链接]
跳转到指定楼层
楼主
ID:635572 发表于 2020-5-13 17:04 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. #include <STC12C5A60S2.h>
  2. #define uchar unsigned char
  3. #define uint  unsigned int
  4. #define ulong unsigned long
  5. uchar code acLEDCS[] = {0xef, 0xdf, 0xbf, 0x7f};              /* 位选地址码，低电平有效，接在P2口的高四位*/
  6. uchar code acLEDCS1[] = {0xe7, 0xd7, 0xb7, 0x77};
  7. uchar code acLedSegCode[]={0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f, 0x77, 0x7c}; /* 段码 */
  8. uchar acLED[4];          /* 显示缓冲区 */
  9. char cScanIndex;      /* 位选指针 0~3 */
  10. uchar cKey;              /* 初始键值    */
  11. uchar cKeyCode;       /* 键值 */
  12. uint nDelayKey;       /*键盘延时变量，为定时中断间隔时间的整数倍*/
  13. uchar cLongDelay;     /* 按键长按时间*/

  15. bit bStill;           /*是否松键标志*/
  16. char cMode = 2;       /*显示方式变量，0~3对应4种方式*/
  17. char cSetMode = 0;        /*功能模式变量，0~10对应11种方式*/
  18. uint nTimer1 = 0;         /*定时计数变量，为定时中断间隔时间的整数倍*/
  19. uint nTimer = 0;          /*定时计数变量，为定时中断间隔时间的整数倍*/
  20. /*********闹铃，低电平有效**************/
  21. uchar cTimeMin = 0;    /*闹铃定时时间变量:分钟*/
  22. uchar cTimeHour = 0;    /*闹铃定时时间变量：小时*/
  23. uchar cTimeflag = 0;
  24. sbit bell = P2^3;
  25. int flag = 0;

  27. /************* 秒表 *************/

  29. uint nStopflag = 0;    /*秒表计数开始标志，为1有效*/
  30. uint nStop = 0;    /*秒表计数，为中断的整数倍：100uS*/
  31. uint nStopSec = 0; /*秒表的秒*/
  32. uint nStopTenms = 0; /* 秒表的亳秒*/

  34. uint ncountSec = 30; /*倒计时的秒*/
  35. uint ncountTenms = 0; /* 倒计时的亳秒*/
  36. uint ncountflag = 0;    /*倒计时 开始标志，为1有效*/
  37. uint ncount = 0;    /*倒计时 计数，为中断的整数倍：100uS*/

  39. /*通用位寻址寄存器*/

  41. uchar bdata Reg = 0;
  42. sbit bReg0 = Reg^0;    /* 串行移位之用*/
  43. sbit bReg7 = Reg^7;    /* 串行移位之用*/
  44. /************ DS 1302 驱动程序 ************* */
  45. sbit DS_CLK = P1^4;
  46. sbit DS_IO = P1^5;
  47. sbit DS_RST = P1^6;


  50. typedef struct StrClock
  51. {
  52.     uchar Sec;    /* 秒 */
  53.     uchar Min;    /* 分 */
  54.     uchar Hour;    /* 时 */
  55.     uchar Day;    /* 日 */
  56.     uchar Mon;    /* 月 */
  57.     uchar Week;    /*星期*/
  58.     uchar Year;    /* 年 */
  59.     uchar Ctr;    /*控制字*/
  60. };
  61. union UniClock    /*时钟联合体1*/
  62. {
  63.     struct StrClock    sClock;
  64.     uchar Time[8];   
  65. }idata uClock;    /*时钟*/



  69. typedef struct StrTime /* 时钟结构体 2 */
  70. {
  71. uchar    Sec;    /* 秒 */
  72. uchar    Min;    /* 分 */
  73. uchar    Hour;    /* 时 */
  74. uchar    Day;    /* 日 */
  75. uchar    Mon;    /* 月 */
  76. uchar    Year;    /* 年 */
  77. };        
  78. union UniTime    /*时钟联合体2 */
  79. {        
  80.     struct StrTime sTime;
  81.     uchar Time[6];
  82. } idata uTime;    /* 时钟 */

  84. /* 16进制码转换为BCD码*/

  86. uchar H_BCD(uchar dat)
  87. {
  88.     uchar datl, dat2;
  89.     datl = dat / 10;
  90.     dat2 = dat % 10 + (datl<<4);
  91.     return(dat2);
  92. }
  93. void W_DS1302(uchar adr, uchar dat);/* 写一字节(dat)到指定地址(adr)*/
  94. uchar R_DS1302(uchar adr);
  95. /***************************************************/
  96. /***** DS 1302 驱动程序 *****/
  97. /*初始化*/
  98. void InitDS1302()
  99. {
  100.     uchar dat;

  102.     W_DS1302(0x8e, 0);             /* 控制命令,禁止写保护 */
  103.     W_DS1302(0x90, 0xa5);        /* 2K电阻,一个二极管 */
  104.     dat=R_DS1302(0x81);            /* 读秒字节 */
  105.     if(dat>127)
  106.     {
  107.         dat=0;
  108.         W_DS1302(0x80, dat);    /* 启动时钟 */
  109.     }   
  110.     W_DS1302(0x8e,0x80);         /* 控制命令,使能写保护 */
  111. }

  113. /* 写一字节 */
  114. void W_DS1302Byte(uchar dat)
  115. {
  116.     uchar i=8;
  117.     Reg=dat;
  118.     while(i--)
  119.     {
  120.         DS_CLK=0;
  121.         DS_IO=bReg0;
  122.         DS_CLK=1;
  123.         Reg >>=1;
  124.     }
  125. }
  126. /*读一字节*/
  127. uchar R_DS1302Byte()
  128. {
  129.         uchar i = 8;
  130.         while(i--)
  131.         {
  132.             DS_CLK = 0;
  133.             Reg >>= 1;
  134.             bReg7 = DS_IO;
  135.             DS_CLK = 1;
  136.         }
  137.         return(Reg);
  138. }
  139. /*写一字节(dat)到指定地址(adr) */
  140. void W_DS1302(uchar adr, uchar dat)
  141. {
  142.     DS_CLK = 0;
  143.     DS_RST = 0;
  144.     DS_RST = 1;
  145.     W_DS1302Byte(adr);    /* 地址，命令 */
  146.     W_DS1302Byte(dat);    /* 写 IByte 数据*/
  147.     DS_RST = 0;
  148.     DS_CLK = 0;
  149. }
  150. /*读一字节指定地址(adr)的数据*/
  151. uchar R_DS1302(uchar adr)
  152. {
  153.     uchar dat;
  154.     DS_CLK = 0;
  155.     DS_RST = 1;
  156.     W_DS1302Byte(adr);    /* 地址，命令 */
  157.     dat=R_DS1302Byte();    /* 读 IByte 数据 */
  158.     DS_RST = 0;
  159.     DS_CLK = 0;
  160.     return(dat);
  161. }
  162. /***************** 读时钟数据 ******************/
  163.    
  164.     /*格式为：秒分时日月星期年控制*/
  165. void R_DS1302Timer()
  166.     {
  167.         uchar i;
  168.         DS_CLK = 0;
  169.         DS_RST = 1;
  170.         W_DS1302Byte(0xbf); /* Oxbf:时钟多字节读命令 */
  171.         for(i = 0; i < 8; i++)
  172.         uClock.Time[i] = R_DS1302Byte();
  173.         DS_RST = 0;
  174.         DS_CLK = 0;
  175.     }
  176. /*************** 数码管显示函数 ****************** /*加(I 0x80)是为了点亮该数码管的小数点*/
  177. void display()
  178. {
  179.     {
  180.         if(cSetMode > 0 )
  181.         {
  182.             switch(cMode)
  183.             {

  185.             case 0:  //显示设置年
  186.                 acLED[0] = acLedSegCode[2];
  187.                 acLED[1] = acLedSegCode[0];
  188.                 acLED[2] = acLedSegCode[uTime.sTime.Year /10];
  189.                 acLED[3] = acLedSegCode[uTime.sTime.Year %10];
  190.                 break;
  191.             case 1: //显示设置月/设置日
  192.                 acLED[0] = acLedSegCode[uTime.sTime.Mon /10];
  193.                 acLED[1] = acLedSegCode[uTime.sTime.Mon %10] | 0x80;
  194.                 acLED[2] = acLedSegCode[uTime. sTime. Day / 10];
  195.                 acLED[3] = acLedSegCode[uTime. sTime. Day % 10];
  196.                 break;
  197.             case 2:   //显示设置时/设置分
  198.                 if (cSetMode == 1 || cSetMode == 2)
  199.                 {
  200.                     acLED[0] = acLedSegCode[uTime.sTime.Hour /10];
  201.                     acLED[1] = acLedSegCode[uTime.sTime.Hour %10] | 0x80;
  202.                     acLED[2] = acLedSegCode[uTime. sTime. Min / 10];
  203.                     acLED[3] = acLedSegCode[uTime. sTime. Min % 10];
  204.                     break;
  205.                 }
  206.                 else if (cSetMode == 3 || cSetMode == 4)
  207.                 {
  208.                     acLED[0] = acLedSegCode[cTimeHour /10];
  209.                     acLED[1] = acLedSegCode[cTimeHour %10] | 0x80;
  210.                     acLED[2] = acLedSegCode[cTimeMin / 10];
  211.                     acLED[3] = acLedSegCode[cTimeMin % 10];
  212.                     break;
  213.                 }
  214.             case 3: //显示设置秒
  215.                 acLED[0] = 0;
  216.                 acLED[1] = 0 | 0x80;
  217.                 acLED[2] = acLedSegCode[uTime.sTime.Sec /10];
  218.                 acLED[3] = acLedSegCode[uTime.sTime.Sec %10];
  219.                 break;
  220.             case 6:
  221.                 acLED[0] = acLedSegCode[ncountSec / 10];
  222.                 acLED[1] = acLedSegCode[ncountSec % 10] | 0x80;
  223.                 acLED[2] = acLedSegCode[ncountTenms / 10];
  224.                 acLED[3] = acLedSegCode[ncountTenms % 10];
  225.                 break;
  226.             case 7: // 显示
  227.                 acLED[0] = acLedSegCode[nStopSec / 10];
  228.                 acLED[1] = acLedSegCode[nStopSec % 10] | 0x80;
  229.                 acLED[2] = acLedSegCode[nStopTenms / 10] ;
  230.                 acLED[3] = acLedSegCode[nStopTenms % 10];
  231.                 break;
  232.             default:
  233.                 break;
  234.             }
  235.         }
  236.           else
  237.         {
  238.             switch(cMode)
  239.             {

  241.             case 0:  //显示年
  242.                 acLED[0] = acLedSegCode[2];
  243.                 acLED[1] = acLedSegCode[0];
  244.                 acLED[2] = acLedSegCode[uClock.Time[6] >>4];
  245.                 acLED[3] = acLedSegCode[uClock.Time[6] & 0x0f];
  246.                 break;
  247.             case 1: //显示月/日
  248.                 acLED[0] = acLedSegCode[uClock.Time[4]>>4];
  249.                 acLED[1] = acLedSegCode[uClock.Time[4] & 0x0f] | 0x80;
  250.                 acLED[2] = acLedSegCode[uClock.Time[3] >>4];
  251.                 acLED[3] = acLedSegCode[uClock.Time[3] & 0x0f];
  252.                 break;
  253.             case 2:   //显示时/分
  254.                
  255.                 acLED[0] = acLedSegCode[uClock.Time[2]>>4];
  256.                 acLED[1] = acLedSegCode[uClock.Time[2] & 0x0f] | 0x80;
  257.                 acLED[2] = acLedSegCode[uClock.Time[1] >>4];
  258.                 acLED[3] = acLedSegCode[uClock.Time[1]& 0x0f];
  259.                 break;
  260.             case 3: //显示?
  261.                 acLED[0] = acLedSegCode[uClock.Time[1] >>4];
  262.                 acLED[1] = acLedSegCode[uClock.Time[1]& 0x0f] | 0x80;
  263.                 acLED[2] = acLedSegCode[uClock.Time[0] >>4];
  264.                 acLED[3] = acLedSegCode[uClock.Time[0] & 0x0f];
  265.                 break;
  266.             case 4:
  267.                 acLED[0] = acLedSegCode[0];
  268.                 acLED[1] = acLedSegCode[0];
  269.                 acLED[2] = acLedSegCode[0];
  270.                 acLED[3] = acLedSegCode[0];
  271.                 break;
  272.             default:
  273.                 break;
  274.             
  275.             }
  276.         }
  277.      }
  278. }
  279. /******************** 按键处理程序 ******************/
  280. void DisposeKEY()
  281. {
  282.     switch(cKeyCode)
  283.     {
  284.     case 2:
  285.         if(bStill == 0)
  286.             {
  287.                 cMode++;
  288.             if(cMode >= 5)
  289.             {
  290.                 cMode = 0;
  291.             }
  292.                 bStill = 1;
  293.             }
  294.             break;
  295.     case 3:   
  296.         /*******设置 DS 1302 的时间*******/
  297.     if (cMode == 0 && cSetMode == 1)/*修改年数*/
  298.     {
  299.         if(uTime.sTime.Year < 99)
  300.         {
  301.             uTime.sTime.Year++;
  302.             nDelayKey = 2000;    /*按住键不动，可连续产生键值，相当于连续按键*/
  303.         }
  304.         W_DS1302(0x8e, 0);    /*控制命令，禁止写保护*/
  305.         W_DS1302(0x8c, H_BCD(uTime.sTime.Year));
  306.         W_DS1302(0x8e, 0x80);    /*控制命令，使能写保护*/
  307.         break;
  308.     }
  309.     else if(cMode == 1 && cSetMode == 1)/*修改月数*/
  310.     {
  311.         if (uTime.sTime.Mon < 12)
  312.         {
  313.             uTime.sTime.Mon++;
  314.             nDelayKey = 2000;
  315.         }
  316.         W_DS1302(0x8e, 0);
  317.         W_DS1302(0x88, H_BCD(uTime.sTime.Mon));
  318.         W_DS1302(0x8e, 0x80);
  319.         break;
  320.     }
  321.     else if(cMode == 1 && cSetMode == 2) /*修改天数*/
  322.     {
  323.         if(uTime.sTime.Day < 31)
  324.         {
  325.             uTime.sTime.Day++;
  326.             nDelayKey = 2000;
  327.         }
  328.         W_DS1302(0x8e, 0);
  329.         W_DS1302(0x86, H_BCD(uTime.sTime.Day));
  330.         W_DS1302(0x8e, 0x80);
  331.         break;
  332.     }
  333.    
  334.     else if(cMode == 2 && cSetMode == 1) /*修改小时数*/
  335.     {
  336.         if(uTime.sTime.Hour < 24)
  337.         {
  338.             uTime.sTime.Hour++;
  339.             nDelayKey = 2000;
  340.         }
  341.         W_DS1302(0x8e, 0);
  342.         W_DS1302(0x84, H_BCD(uTime.sTime.Hour));
  343.         W_DS1302(0x8e, 0x80);
  344.         break;
  345.     }
  346.     else if(cMode == 2 && cSetMode == 2) /*修改分钟数*/
  347.     {
  348.         if(uTime.sTime.Min < 59)
  349.          {
  350.             uTime.sTime.Min++;
  351.             nDelayKey = 2000;
  352.         }
  353.         W_DS1302(0x8e, 0);
  354.         W_DS1302(0x82, H_BCD(uTime.sTime.Min));
  355.         W_DS1302(0x8e, 0x80);
  356.         break;
  357.     }
  358.     /********设置闹铃时间*******/
  359.     else if(cMode == 2 && cSetMode == 3)/*设置闹铃小时数*/
  360.     {
  361.         if(cTimeHour < 24)
  362.             {
  363.                 cTimeHour++;
  364.                 nDelayKey = 2000;
  365.             }
  366.             break;
  367.     }
  368.     else if(cMode == 2 && cSetMode == 4)/*设置闹铃分钟数*/
  369.     {
  370.         if(cTimeMin < 59)
  371.             {
  372.                 cTimeMin++;
  373.                 nDelayKey = 2000;
  374.             }
  375.             break;
  376.     }


  379.     else if (cMode == 3 && (cSetMode == 1)) /*修改 秒数*/
  380.     {
  381.         if (uTime.sTime.Sec < 59)
  382.         {
  383.             uTime.sTime.Sec++;
  384.             nDelayKey = 2000;
  385.         }
  386.         W_DS1302(0x8e, 0);
  387.         W_DS1302(0x80, H_BCD(uTime.sTime.Sec));
  388.         W_DS1302(0x8e, 0x80);
  389.         break;
  390.     }
  391.     else if (cMode == 6 && cSetMode == 3) /*修改 倒计时分 */
  392.     {
  393.         if( ncountSec < 91)
  394.         {
  395.             ncountSec++;
  396.             nDelayKey = 2000;
  397.         }
  398.         ncountTenms = 0;
  399.         if (ncountSec == 91)
  400.             ncountSec = 0;
  401.         break;
  402.     }
  403.    
  404.     else
  405.         {
  406.             break;
  407.         }
  408.     case 6:    /*功能：KeySUB */
  409. /********设置 DS1302 的时间*********/
  410.         if (cMode == 0 && cSetMode == 1 )/*修改年数*/
  411.         {
  412.             if(uTime.sTime.Year > 0)
  413.             {
  414.                 uTime.sTime.Year--;
  415.                 nDelayKey = 1000;
  416.             }
  417.             W_DS1302(0x8e, 0);
  418.             W_DS1302(0x8c, H_BCD(uTime.sTime.Year));
  419.             W_DS1302(0x8e, 0x80);
  420.             nDelayKey = 2000;
  421.             break;
  422.         }
  423.         else if(cMode == 1 && cSetMode == 1)/*修改月数*/
  424.         {
  425.             if(uTime.sTime.Mon > 0)
  426.             {
  427.                 uTime. sTime.Mon--;
  428.                 nDelayKey = 2000;
  429.             }
  430.             W_DS1302(0x8e, 0);
  431.             W_DS1302(0x88, H_BCD(uTime. sTime. Mon));
  432.             W_DS1302(0x8e, 0x80);
  433.             break;
  434.         }
  435.         else if (cMode == 1 && cSetMode == 2)/*修改天数*/
  436.         {
  437.             if(uTime. sTime. Day > 0)
  438.             {
  439.                 uTime.sTime.Day--;
  440.                 nDelayKey = 2000;
  441.             }
  442.             W_DS1302(0x8e, 0);
  443.             W_DS1302(0x86, H_BCD(uTime.sTime.Day));
  444.             W_DS1302(0x8e, 0x80);
  445.             break;
  446.         }
  447.         else if(cMode == 2 && cSetMode == 1)/*修改小时数*/
  448.         {
  449.             if(uTime.sTime.Hour > 0)
  450.             {
  451.                 uTime.sTime.Hour--;
  452.                 nDelayKey = 1000;
  453.             }
  454.             W_DS1302(0x8e, 0);
  455.             W_DS1302(0x84, H_BCD(uTime.sTime.Hour));
  456.             W_DS1302(0x8e, 0x80);
  457.             break;
  458.         }
  459.         else if(cMode == 2 && cSetMode == 2)/*修改分钟数*/
  460.         {
  461.             if(uTime.sTime.Min > 0)
  462.             {
  463.                 uTime.sTime.Min--;
  464.                 nDelayKey = 2000;
  465.             }
  466.         W_DS1302(0x8e, 0);
  467.         W_DS1302(0x82, H_BCD(uTime.sTime.Min));
  468.         W_DS1302(0x8e, 0x80);
  469.         break;
  470.         }
  471.         else if (cMode == 3 && (cSetMode == 1 )) /*修改 秒数*/
  472.         {
  473.             if(uTime.sTime.Sec > 0)
  474.             {
  475.                 uTime.sTime.Sec--;
  476.                 nDelayKey = 2000;
  477.             }
  478.             W_DS1302(0x8e, 0);
  479.             W_DS1302(0x80, H_BCD(uTime.sTime.Sec));
  480.             W_DS1302(0x8e, 0x80);
  481.             break;
  482.         }
  483. /********设置闹铃时间********/
  484.         else if (cMode == 2 && cSetMode == 3)/*设置闹铃小时数*/
  485.         {
  486.             if(cTimeHour > 0)
  487.             {
  488.                 cTimeHour--;
  489.                 nDelayKey = 2000;
  490.             }
  491.             break;
  492.         }

  494.         else if(cMode == 2 && cSetMode == 4)/*设置闹铃分钟数*/
  495.         {
  496.             if(cTimeMin > 0)
  497.             {
  498.                 cTimeMin --;
  499.                 nDelayKey = 2000;
  500.             }
  501.             break;
  502.         }
  503.         else if (cMode == 6 && cSetMode == 3) /*修改 倒计时分 */
  504.         {
  505.             if(ncountSec > 0)
  506.             {
  507.                 ncountSec--;
  508.                 nDelayKey = 2000;
  509.             }
  510.             ncountTenms = 0;
  511.             if (ncountSec == 0)
  512.             ncountSec = 90;            
  513.             break;
  514.         }
  515.         else
  516.         {
  517.             break;
  518.         }
  519.     case 5:   
  520.             
  521.             if(bStill == 0)
  522.             {
  523.                 cSetMode++;
  524.                 bStill = 1;
  525.             }
  526.             if(cMode == 0 && cSetMode == 2)
  527.         {
  528.             cSetMode = 0;
  529.             break;
  530.         }
  531.         else if(cMode == 1 && cSetMode == 3)
  532.         {
  533.             cSetMode = 0;
  534.             break;
  535.         }
  536.         else if(cMode == 2 && cSetMode == 5)
  537.         {
  538.             cSetMode = 0;
  539.             break;
  540.         }
  541.         else if(cMode == 2 && cSetMode == 1&& cTimeflag == 1)
  542.         {
  543.             cTimeHour = 24;
  544.             cTimeMin = 60;
  545.             cTimeflag =0;
  546.             break;
  547.         }
  548.         
  549.         
  550.         
  551.         else if(cMode == 3 && cSetMode == 2)
  552.         {
  553.             cSetMode = 0;
  554.             break;
  555.         }
  556.         else if(cMode == 6 && cSetMode == 6)
  557.         {
  558.             cSetMode = 0;
  559.             cMode =4;
  560.             ncountTenms = 0;
  561.             ncountSec = 30;
  562.             nStopTenms = 0;
  563.             nStopSec = 0;
  564.             
  565.             break;
  566.         }
  567.         else if(cMode == 3 && cSetMode == 2)
  568.         {
  569.             cSetMode = 0;
  570.             break;
  571.         }
  572.         else if(cMode == 7 && cSetMode == 3)
  573.         {
  574.             ncountflag = 1;
  575.             break;
  576.         }
  577.         else if(cMode == 6 && cSetMode == 5)
  578.         {
  579.             ncountflag = 0;
  580.             break;
  581.         }
  582.         else if(cMode == 4 && cSetMode == 1)
  583.         {
  584.             nStopflag = 1;
  585.             break;
  586.         }
  587.         else if(cMode == 7 && cSetMode == 2)
  588.         {
  589.             nStopflag = 0;
  590.             break;
  591.         }
  592.         else
  593.         {
  594.             break;
  595.         }
  596.     }
  597.    
  598.         display ();
  599.         cKeyCode = 0;
  600. }



  604. void Alarm()
  605. {
  606.     if (cTimeHour - uClock.Time[2]  == 0&& cTimeMin - uClock.Time[1]  == 0&& cSetMode == 0 )
  607.     {   
  608.         cTimeflag = 1;    /*启动闹铃*/
  609.         bell = 0;
  610.     }
  611.     else    /*不启动闹铃*/
  612.         bell = 1;
  613.         cTimeflag = 0;    /*不启动闹铃*/
  614.         
  615. }
  616. /****************** 秒表函 数 *******************/
  617. void StopWatch()
  618. {
  619.     if(nStopflag == 1)
  620.     {
  621.         cMode = 7;
  622.         if(nStop >= 100)
  623.         {
  624.             nStop = 0;
  625.             nStopTenms++;
  626.             if(nStopTenms >= 100) /*100*10ms=ls*/
  627.             {
  628.                 nStopTenms = 0;
  629.                 if(nStopSec < 99)
  630.                     nStopSec++; /*秒表秒加一*/
  631.                 else    /*最长秒表为99.99s*/
  632.                 {
  633.                     nStopSec = 99;
  634.                     nStopTenms = 99;
  635.                     nStopflag = 0;
  636.                 }
  637.             }
  638.         }
  639.     }
  640.    
  641.     display();
  642. }
  643. void CountDown(void)

  645. {
  646.     if (ncountflag == 1)
  647.     {
  648.         cMode= 6;
  649.     }
  650.     if(cMode == 6 && cSetMode == 4)/*开始倒计时*/

  652.     {
  653.         if(ncount >= 100)
  654.         {
  655.             ncount = 0;
  656.             if (ncountTenms != 0)
  657.             {
  658.             ncountTenms--;
  659.             }
  660.             else if(ncountTenms==0 && ncountSec != 0)
  661.             {
  662.                 ncountTenms =99;
  663.                 ncountSec--;
  664.             }
  665.             
  666.             else
  667.             {
  668.                 ncountTenms =0;
  669.                 ncountSec = 0;
  670.                 ncountflag = 0;
  671.             }
  672.         }
  673.     }
  674. }
  675. /************************** 主函数 *****************************/
  676. void main(void)
  677. /**************** 定时器初始化 *******************/
  678. {
  679.     AUXR &= 0x7F;   
  680.     TMOD &= 0xF0;        
  681.     TMOD |= 0x01;        
  682.     TL0 = 0x48;        
  683.     TH0 = 0xFF;   
  684.     TF0 = 0;        
  685.     TR0 = 1;        
  686.     ET0 = 1;
  687.     EA = 1;        /*开总中断*/
  688.     P0M0 = 0xff; /*定义P0 口为强推挽模式*/
  689.     P0M1 = 0x00; /*POM1 = 00000000B*/
  690.     InitDS1302();  /* 初始化 DS1302 */
  691.     R_DS1302Timer();  /*读时钟数据()*/
  692.     display();  /*显示初始界面*/
  693.     while(1)



  697.     {
  698.         if(cKeyCode != 0)
  699.         {
  700.             DisposeKEY(); /*响应按键操作*/
  701.         }
  702.         R_DS1302Timer();      /*读时钟数据*/
  703.         display() ;  /*显示函数*/
  704.         Alarm();     /*闹铃函数*/
  705.         StopWatch();  /*秒表函数*/
  706.         CountDown();  /*倒计时函数*/
  707.     }
  708. }
  709. /**************** 多任务时序控制时钟中断 *****************/
  710. void IntT0() interrupt 1
  711. {
  712.     TL0 = 0x48;        
  713.     TH0 = 0xFF;   
  714.     nTimer1++;
  715.    
  716.     if(ncountflag == 1)
  717.     {        
  718.             ncount++;    /*秒表计数，为中断的整数倍：100us*/
  719.     }
  720.     if(nStopflag == 1)
  721.     {        
  722.             nStop++;    /*秒表计数，为中断的整数倍：100us*/
  723.     }
  724.      if (cTimeflag == 1)
  725.     {
  726.                     P0 = 0;
  727.                     P2 = acLEDCS1[cScanIndex];
  728.                     P0 = acLED[cScanIndex++];
  729.                     cScanIndex &= 3;
  730.     }
  731.     else
  732.         {
  733.         if (cSetMode > 0 && cSetMode < 8)    /*此处用于闪烁时，设置时间及闹铃。闪烁是通过数码管间歇性显示有效实现的*/
  734.         {   
  735.             if(nTimer1 <= 2500 )
  736.             {
  737.                 if (cMode == 0 && cSetMode == 1 ) /*设置 年时，数码管闪烁*/
  738.                                                               /*先淸显示再换位选*/
  739.                 {
  740.                     P0 = 0;
  741.                     P2 = acLEDCS[cScanIndex];
  742.                     cScanIndex++;
  743.                     P0 = 0;
  744.                     cScanIndex &= 3;
  745.                 }
  746.                     else if(cSetMode == 1 && cMode == 1)
  747.                     {
  748.                         P0 = 0;
  749.                         P2 = acLEDCS[cScanIndex];
  750.                         cScanIndex++;
  751.                         if(cScanIndex >= 1 && cScanIndex <= 2)
  752.                             P0 = 0;
  753.                         else
  754.                         {
  755.                             P0 = acLED[cScanIndex - 1];
  756.                             cScanIndex &= 3;
  757.                         }
  758.                     }
  759.                     else if(cSetMode == 2 && cMode == 1) /*日时，后两位数码管闪烁*/
  760.                     {
  761.                         P0 = 0;
  762.                         P2 = acLEDCS[cScanIndex];
  763.                         cScanIndex++;
  764.                         if(cScanIndex >= 3 && cScanIndex <= 4)
  765.                         {
  766.                             P0 = 0;   
  767.                             cScanIndex &= 4;    /*位选指针回位*/
  768.                         }
  769.                         else   
  770.                             P0 = acLED[cScanIndex - 1];    /*送显示数据,位选指针移位*/   
  771.                     }         
  772.                     else if(cSetMode == 1 && cMode == 2)    /*设置小时，前两位数码管闪烁*/
  773.         
  774.                     {
  775.                         P0 = 0;    /*先淸显示再换位选*/   
  776.                         P2 = acLEDCS[cScanIndex];    /*送位选数据*/   
  777.                         cScanIndex++;   
  778.                         if(cScanIndex >= 1 && cScanIndex <= 2)   
  779.                             P0 = 0;   
  780.                         else
  781.                         {
  782.                             P0 = acLED[cScanIndex - 1];    /*送显示数据,位选指针移位*/   
  783.                             cScanIndex &= 3;    /*位选指针回位*/
  784.                         }
  785.                     }

  787.                     else if(cSetMode == 2 && cMode == 2)    /*设置分钟时，后两位数码管闪烁*/
  788.                     {   
  789.                         P0 = 0;/*先淸显示再换位选*/
  790.                         P2 = acLEDCS[cScanIndex] ;    /* 送位选数据*/
  791.                         cScanIndex++;
  792.                         if(cScanIndex >= 3 && cScanIndex <= 4)
  793.                         {
  794.                             P0 = 0;
  795.                             cScanIndex &= 4;    /* 位选指针回位*/
  796.                         }
  797.                         else
  798.                             P0 = acLED[cScanIndex - 1];    /* 送显示数据,位选指针移位*/
  799.                     }
  800.                     else if (cMode == 3 && (cSetMode == 1 || cSetMode == 2))/*设置秒时，数码管闪烁*/

  802.                     {
  803.                         P0 = 0;    /*先清显示再换位选*/   
  804.                         P2 = acLEDCS[cScanIndex];    /*送位选数据*/        
  805.                         cScanIndex++;   
  806.                         P0 = 0;   
  807.                         cScanIndex &= 3;    /*位选指针回位*/        
  808.                     }
  809.                     else if(cSetMode == 3 && cMode == 2)    /*设置闹铃小时时，    前两位数码管闪烁*/
  810.                     {
  811.                         P0 = 0;    /*先淸显示再换位选*/   
  812.                         P2 = acLEDCS[cScanIndex];    /*送位选数据*/

  814.                         cScanIndex++;
  815.                         if(cScanIndex >= 1 && cScanIndex <= 2)
  816.                             P0 = 0;
  817.                     
  818.                         else
  819.                         {
  820.                             P0 = acLED[cScanIndex -1];  
  821.                             cScanIndex &= 3;
  822.                         }
  823.                     }
  824.                     else if(cSetMode == 4 && cMode == 2)
  825.                     {
  826.                         P0 = 0;
  827.                         P2 = acLEDCS[cScanIndex];
  828.                         cScanIndex++;
  829.                         if(cScanIndex >= 3 && cScanIndex <= 4)
  830.                         {
  831.                             P0 = 0;
  832.                             cScanIndex &= 4;
  833.                         }
  834.                         else
  835.                             P0 = acLED[cScanIndex - 1];
  836.                     }
  837.                     else if(cMode == 6 && cSetMode == 3)
  838.                     {
  839.                         P0 = 0;    /*先淸显示再换位选*/   
  840.                         P2 = acLEDCS[cScanIndex];    /*送位选数据*/   
  841.                         cScanIndex++;   
  842.                         if(cScanIndex >= 1 && cScanIndex <= 2)   
  843.                             P0 = 0;   
  844.                         else
  845.                         {
  846.                             P0 = acLED[cScanIndex - 1];    /*送显示数据,位选指针移位*/   
  847.                             cScanIndex &= 3;    /*位选指针回位*/
  848.                         }
  849.                     }
  850.                     else /*不闪烁*/
  851.                     {
  852.                         P0 = 0;
  853.                         P2 = acLEDCS[cScanIndex];
  854.                         P0 = acLED[cScanIndex++];
  855.                         cScanIndex &= 3;
  856.                     }
  857.                 }

  859.                 else

  861.                 {
  862.                     if(nTimer1 >= 5000 )
  863.                         nTimer1 = 0;
  864.                     P0 = 0;
  865.                     P2 = acLEDCS[cScanIndex];
  866.                     P0 = acLED[cScanIndex++];
  867.                     cScanIndex &= 3;
  868.                 }
  869.             }
  870.             else   
  871.             {
  872.                 P0 = 0;
  873.                 P2 = acLEDCS[cScanIndex];
  874.                 P0 = acLED[cScanIndex++];
  875.                 cScanIndex &= 3;
  876.             }
  877.     }
  878. /*********************扫 描按键********************/
  879.         if(nDelayKey == 0)
  880.         {
  881.             cKey = P2 & 0x07;  /* 取键值 P20、P21、P22*/
  882.             if(cKey != 0x07)
  883.                 nDelayKey = 100;       /*设置延退时间削颤*/
  884.             else
  885.             {

  887.                 bStill = 0;
  888.                 cLongDelay = 0;/*松键*//*有按键利用DelayKey按键消颤*/
  889.             }
  890.         }
  891.         else
  892.         {
  893.             nDelayKey--;
  894.             if(nDelayKey == 0)
  895.             {
  896.                 cKeyCode = P2 & 0x07;
  897.                 if(cKey != cKeyCode)
  898.                 {
  899.                     cKeyCode = 0;
  900.                 }
  901.             }
  902.         }
  903. }
复制代码
单片机
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:635572 发表于 2020-5-13 17:06 | 只看该作者
这是一个完整的系统，里面包含了年月日，闹钟，计时，以及跳转设置等
回复

使用道具 举报

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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