clockcode.txt

基于单片机的定时和控制装置在许多行业有着广泛的应用

程序源代码
  全部的程序将分为3部分，分别是头文件和变量的定义、主程序MAIN（）以及各个功能子函数。
//定义头文件和各个输入管脚以及变量声明
#include <reg52.h>
#include <absacc.h>
#define  unit unsigned inf
#define  uchar unsigned  char
/* 定义字型字位口 */
#define  DIGPORT  XBYTE  [0X8000]
#define  WORDPORT  XBYTE [0X4000]
/* 定义P1口各管脚 */
sbit  k0=p1^0;
sbit  K1=P1^1;
sbit  K2=P1^2;
sbit  BEEP=P1^3;
sbit  L0=P1^4;
sbit  L1=P1^5;
sbit  L2=P1^6;  
sbit  L3=P1^7;
 
uchar data BUFFER[2]={0,0};              /*显示缓冲区（依次为低位、高位）*/
uchar data  CLOCK[4]={0,0,0,0};          /*存放时钟时间（依次为百分秒，秒，分和时位）*/
uchar data  SECOND[2]={0,0};             /*存放秒表时间（依次为百分秒，秒）*/
uchar data  REVERSE[4]={0,0,0,0};        /*存放倒计时时间（依次为百分秒，秒，分和时位）*/

/* 定义运行状态  */
uchar data  state=0;
/* STATE=0，秒表 */
/* STATE=1，倒计时分调整*/
/* STATE=2，倒计时秒调整 */
/* STATE=3，倒计时运行 */
/* STATE=4or7，时钟运行 */
/* STATE=5，时钟分调整*/
/* STATE=6，时钟时调整 */

bit bdata  SND=0；
bit bdata  RST=0；
bit bdata  STP=0；
 /*  */
uchar code TABLE[] {0X3f，0x06，0x5b，ox4f，0x66，0x6d，0x7d，0x07，0x7f，0x6f，0x77，0x40}；
//主程序  
在主程序中需要完成以下功能；首先是对定时器和变量进行初始化，然后是循环运行时钟的选定功能。在循环中首先根据变量“STATE”判断当前时钟运行状态，并对其作变量的初始化。其次，如果“STATE”状态保持不变，则执行当前按踺选定的时钟功能。在时钟运行过程中，按照选定的运行状态分别调用了以下的功能函数：
  timer0（void）：  由定时器0所对应的24小时的时钟显示。
  timer1（void）：  由定时器1所对应的秒表和倒计时功能。
  intsvr1（void）：  由外中断1的按键脉冲所对应的时间调整功能。
  timer1（void）：  由定时器1的外部按键脉冲所对应的秒表初值调整功能。
而相应的时间显示部分功能则由DISPLAY（） 函数完成
/-----------------------------------------------------------
void main（void）
{
   uchar stabak；                /*上一次程序运行的状态*/
   p1=0x0f；
   EA=1；IT1=1；ET0=1；
   TMOD=0X61；                   /*T1方式2计数,T0方式1计时*/
   TH0=5000/256；TL0=-5000%256；
   TH1=0Xff;TL1=0Xff;
   T2CON=0;TH2=-5000/256;TL2=-5000%256；

   K0=1；K1=1；K2=1；
   STATE=P1&0X07;
   stabak=STAATE;
   for(;;)
   {
     switch (STATE)
      {
        case0:                     /*STATE=0,秒表*/
         {
           EX1=0;ET1=1;ET2=1;TR1=1;SND=1;
           L1=1;L0=0;L2=0;
           SECOND[0]=0;
           SECOND[1]=0;
         } break;
        case1:                      /*STATE=1,倒计时分调整*/
         {
           EX1=1;ET1=1;ET2=1;TR1=1;TR2=1;
           L2=1;L0=0;L1=0;
           REVERSL[0]=0;
            REVERSL[1]=0;
         }  break;
        case2:                       /*STATE=2,倒计时小时调整*/
         {
           EX1=1;ET1=1;ET2=1;TR1=1;TR2=0;
           L2=1;L0=0;L1=0;
           REVERSL[0]=0;
           REVERSL[1]=0;
         } break;
        case3:                      /*STATE=3,倒计时运行*/
         {
           EX1=0;ET1=1;ET2=1;TR1=1;
           if((REVERSE[2]==0)&&(REVERSE[3]==0))L2=1;
           else  TR2=1;
           L0=0;L1=0;
         }  break;
        case5:                      /*STATE=5,时钟分调整*/
         {
           IE1=0;EX1=1;ET1=0;ET2=1;TR0=0;
           L0=1;L1=0;L2=0;
        }  break;
        case6:                       /*STATE=6,时钟时调整*/ 
         {
           IE1=0;EX1=1;ET1=0;ET2=1;TR0=0;
           L0=1;L1=0;L2=0;
         }  break;
       default:                     /*STATE=4 OR 7,时钟运行*/                 
         {
           EX1=0;ET1=0;ET2=1;TR0=0;
           L1=0;L2=0;
          }
         }
       while(STATE==stabak)
       {
         switch(STATE)
         {
            case0:                 /*STATE=0,秒*/
             {
               BUFFER[0]=SECOND[0];
               BUFFER[1]=SECOND[1];
             } break;
            case1:                 /*STATE=1,倒计时分调整*/
             {
               BUFFER[0]=REVERSE[2];
               BUFFER[1]=101;
             } break;
             case2:                 /*STATE=2,倒计时小时调整*/  
             {
               BUFFER[0]=110;
               BUFFER[1]=REVERSE[3];
             } break;
             case3:                  /*STATE=3,倒计时运行*/
             {
               BUFFER[0]=REVERSE[2];
               BUFFER[1]=REVERSE[3];
             } break;
            case5:                  /*STATE=5,时钟分调整*/
             {
               BUFFER[0]=CLOCK[2];
               BUFFER[1]=101;
             } break;
            case6:                    /*STATE=6,时钟时调整*/ 
             {
               BUFFER[0]=110;
               BUFFER[1]=CLOCK[3];
             } break;
             default;                   /*STATE=4 OR 7,时钟运行*/
              
             {
               BUFFER[0]=CLOCK[2];
               BUFFER[1]=CLOCK[3];
             } 
            }
            //显示函数
            display();
            K0=1;K1=1;K2=1;
            STATE=P1&0X07;
            }
             stabak=STATE;
             }
            }
   //字函数(1):   timer0(void)
      功能: 是使用定时器0完成24小时时钟的显示.
      算法:具体的实现过程可以参看图1-1所示的24小时时钟显示程序流程图.
  void timer0(void)  interrupt1 using1
  {
    /*重置定时器初值 */
    TH0=5000/256;
    TL0=5000%256;
   /* 时钟处理 */
   CLOCK[0]=CLOCK[0]+1;
   if((CLOCK[0]==50)&&(STATE>=4))
   {
     L0=!L0;
   }
   if(CLOCK[0]==100)
     {
      if(STATE>=4)L0=!L0;
      CLOCK[0]=0;
      CLOCK[1]=CLOCK[1]+1;
   if(CLOCK[1]==60)
    {
       CLOCK[1]=0;
      CLOCK[2]=CLOCK[2]+1;
   if(CLOCK[2]==60)
    {
       CLOCK[2]=0;
      CLOCK[3]=CLOCK[3]+1;
   if(CLOCK[3]==24)
    {
       CLOCK[3]=0;
                        }
                      }
                   }
                }
            }
/--------------------------------------------
//字函数(1):   timer0(void)
      功能: 是使用定时器2完成秒表和倒计时功能.
      算法:具体的实现过程可以参看图1-2所示的秒表和倒计时程序流程图.
/----------------------------------------------
  void timer2(void)  interrupt5 using3
  {
    TF2=0;
    TH2=5000/256;
    TL2=5000%256;
   /* 秒表处理 */
   if(STATE==0)
   {
     SECOND[0]=SECOND[0]+1;
     if(SECOND[0]==50)
     {
       L1=!L1;
     }
     if(SECOND[0]==100)
     {
       L1=!L1;
      SECOND[0]=0;
      SECOND[1]=SECOND[1]+1;
     if(SECOND[1]==100)
     { 
       SECOND[1]=0;
      }
     }
    }
  /* 倒计时处理   */
  if(STATE==3)
  {
    REVERSE[0]=REVERSE[0]+1;
    if(REVERSE[0]==50)
    {
      L2=!L2;
     }
    if(REVERSE[0]==100)
    {
      L2=!L2;
    REVERSE[0]=0;
    REVERSE[1]=REVERSE[1]+1;
    if(REVERSE[1]==60)
    {
      REVERSE[1]=00;
      REVERSE[2]=REVERSE[2]+1;
    if((REVERSE[2]==0)&&(REVERSE[3]==0))
    {
      TR2=0;
      STP=1;
      BEEP=0;
    }
    else if(REVERSE[2]==0Xff)
    {
      REVERSE[2]=59;
      REVERSE[3]=REVERSE[3]+1;
      }
     }
    }
   }
  }

 /--------------------------------------------
//字函数(3):   intsvr1(void)。
      功能: 由外中断1的按键脉冲所对应的时间调整功能
      算法:具体的实现过程可以参看图1-3所示的倒计时初值调整程序流程图.
/----------------------------------------------
  void  intsvr1(void)  interrupt2 using2
  {
    if(STATE==5)
    {
      CLOCK[2]=CLOCK[2]+1;
      if(CLOCK[2]==60)CLOCK[2]=0;
    {
      CLOCK[3]=CLOCK[3]+1;
      if(CLOCK[3]==24)CLOCK[3]=0;
    }
  }
/--------------------------------------------
//字函数(4):   timer1(void)
      功能: 通过定时器1的外部按键脉冲所对应的秒表初值调整功能。
      算法:具体的实现过程可以参看图1-4所示的秒表和倒计时程序流程图.
/----------------------------------------------
  void timer1(void)  interrupt3 using3
  {
    if(STATE==0)
    {
      SECOND[0]=0;
      SECOND[1]=0;
      L1=1;
      RST=0;
    }
    else
    {
       if(SND)TR2=1;
       else
       {
         L1=1;
         TR2=1;
         RST=1;
       }
       elseif(STATE==1)
       {
         REVERSE[3]=REVERSE[3]+1:
         if(REVERSE[3]==24)REVERSE[3]=0;
         }
       else
       { 
          if(STP)
             {
                BEEP=1;
                L2=1;
                STP=0;
             }
             else TR2=0;
           }
    }
 /-----------------------------------------------
  字函数(5):   display(void)
      功能: 用动态显示的方法,将当前的时间或秒表内容通过显示器显示.
      算法:有关数码管的动态显示算发和技术参看图1-5所示的"动态扫描"内容.
/----------------------------------------------
  void display(void) 
  {
    uchari;                 /*显示缓冲区首址*/
    uchar delay;            /*显示延时*/
    uchar  disp;            /*显示内容*/
    uchar digit;            /*定义数码管显示位*/
    digit=0x08;    
    for (i=0;i<2;i++)        /*秒表，显示百分秒和秒*/
    {
      if(BUFFER[i] >100)disp=BUFFER[i]%10+10;
      else disp=BUFFER[i]%10;

      DIGPORT=digit;
      WORDPORT=TABLE[disp];
      for(delay=0;delay<=200;delay++);
      digit=digit>>1;
      disp=BUFFER[i]/10;

      DIGPORT=digit;
      WORDPORT=TABLE[disp];

      for(delay=0;delay<=200;delay++)
      digit+digit>>1;
    }
  }