sysinter.c

本公司的单相CPU卡表的源程序代码

/*******************************************************************
*  SysInter.c  : sys interrupt programme
********************************************************************/
#pragma interrupt INTP2 KeyDis_Deal      //display key check  
#pragma interrupt INTP5 HCF_Add          //intp5 interrupt, single-phase's high frequency energy impluse
#pragma interrupt INTSR6 CommRX          //RS485 interface recieve
#pragma interrupt INTST6 CommTX          //RS485 interface send
#pragma interrupt INTSR0 IRCommRX        //IR interface recieve
#pragma interrupt INTST0 IRCommTX        //IR interface send
#pragma interrupt INTWTI WT_4ms          //watch timer of 3.91ms 
#pragma interrupt INTWT  WT_500ms        //watch timer of 500ms 


#include "include\macro.h"  
#include "include\HardConfig.h"
#include "include\SysConfig.h"
#include "include\SubConfig.h"
#include "include\data.h"
#include "include\bitdef.h"

#include "include\FunAnnounce.h"


/*******************************************************************
* KeyDis_Deal(): display key check.
********************************************************************/
void KeyDis_Deal()
{
    PIF2 = 0;             //clear keydisplay interrupt flag.
    NOP();
    if(pin_KEYDIS == 0)   Flag.even |= bitDKen ;   
}

/*******************************************************************
* WT_4ms(): watch timer of 3.91ms
********************************************************************/
void WT_4ms()
{
unsigned char i;
 
    WTIIF = 0;
    NOP();
    
    // add time of energy adj time, need 6s
    if(Flag.run & bitR_Adj)   Sram.cnt_Eadj++;
    
    //energy adjust status test
    if((pin_KEYKWX==0) &&  (pin_KEYCHK== 0))
    {
        if((Flag.even & bitKAdj) == 0)
        {
            Sram.KeyCnt++;
            if(Sram.KeyCnt>16)   
            {
            	Flag.run |= bitR_Adj;    //set adj status in effect flag. 
            	Flag.even |= bitKAdj;    //set hard adj status in effect flag. 
            	Sram.AdjCnt[0] = 0;
            	Sram.cnt_Eadj=0;
            } 
        }
    }
    else
    {
    	Flag.even &= ~bitKAdj;                 // clear program key in effect flag.              
        Sram.KeyCnt = 0;        	
    }
    
    
    // output energy low frequency pluse, about 80mS. 
    if(Flag.run & bitR_EpLED)  
    {
    	Sram.Pul_Tmr++;
    	if(Sram.Pul_Tmr >= 20)
    	{
    	    pin_EPLOUT = 1;                    //SET Epluse-LED OFF
    	    Flag.run &= ~bitR_EpLED;    
        }
    } 
    
    // relay close control
    if(Flag.even & bitRly )  
    {
    	Sram.Rly_Tmr++;
    	if(Sram.Rly_Tmr >= 18)
    	{
    	    pin_CTROFF = 0;                     //
    	    pin_CTRON = 0; 
    	    if(Sram.Rly_Tmr >= 40)           Flag.even &= ~ bitRly;  
        }
    } 
    
    // when rx datas interval > 520ms, UART reset
   // if((Comm.rsErrTmr++) > 150 )      Comm.status = COMM_STATUS_INIT;
    
    //
    if((Comm.status&0x0f)== COMM_STATUS_URTXRDY)
    {
        if(Comm.tmrMd != 0)
        {
            Comm.tmrMd--;
        }
    }
  
}


/*******************************************************************
* WT_500ms(): watch timer of 500ms
********************************************************************/
void WT_500ms()
{
 
    WTIF = 0;
    Flag.even |= bitHfSec ; 
    Flag.even |= bitDisT ;
    
}


/*******************************************************************
* HCF_Add():  intp5 interrupt, single-phase's high frequency energy impluse
********************************************************************/
void HCF_Add()
{
  //unsigned long Tmp= PimpQ;
 
    PIF5 = 0;     //CLR  INTP3  interrupted FLAG.  
    
    if(Flag.run & bitR_Adj)
    {
        Sram.AdjCnt[0]++;	
    }
    else
    {
        Sram.PHFCnt+=Sram.Adj_Base[0];
        if( Sram.PHFCnt >= PimpQ )  
        {
            pin_EPLOUT = 0;               //energy L_pluse output,led open.
            Sram.Pul_Tmr=0;
            //Sram.PHFCnt = 0;
            Sram.PHFCnt -= PimpQ ;
            //Sram.PLFCnt++;
            Flag.run |= bitR_Pulse;       // set energy L_pluse accumulative flag.
            Flag.run |= bitR_EpLED;       // set energy L_pluse accumulative flag.
        }  	
    }
}


/*******************************************************************
* CommRX():  UART6 interrupt, DL645 communication data received
********************************************************************/
void CommRX()
{ 
   register unsigned char i;

    if(ASIS6==0)
    {
        if(Comm.status == COMM_STATUS_FREE)
    	  {
    	      Comm.status = COMM_MODE_RS485 + COMM_STATUS_URRX;
    	      Comm.ptr = 0;    
    	  }
    	  
    	  i = RXB6;
    	  
    	  if(Comm.status != (COMM_MODE_RS485 + COMM_STATUS_URRX))   return;  
        
        Comm.rsErrTmr = 0;
        if( Comm.ptr >= RTx_MaxSize)   return;
        Comm.commBuff[Comm.ptr] = i;
        
        if( Comm.commBuff[0] == 0x68)  
        {
            if( Comm.ptr > 13)
            {
                NOP();
                NOP();	
            }
            Comm.ptr++;
        
        }
        else
        {
            Comm.ptr = 0;	  
        }    
    
    } // end of "if(ASIS6==0)"                                
    else 
    {
    	  i=ASIS6;
        i=RXB6;
        Comm.status = COMM_STATUS_INIT;
    }// end of "if(ASIS6==0)  else " 
}

/*******************************************************************
* CommTX():  UART6 interrupt, DL645 communication data send out
********************************************************************/
void CommTX()
{
    STIF6=0;
    
    if((Comm.status & COMM_MODE_RS485)==0)  return;
    
    Comm.rsErrTmr = 0;
    
    if(Comm.cntFE != 0)
    {
        TXB6 = 0xfe;
        Comm.cntFE--;
    }
    else
    {
        if((Comm.ptr >= RTx_MaxSize) || (Comm.ptr >=(char)(RS_MinSize+Rs_Len) ))  return; 
        TXB6 = Comm.commBuff[Comm.ptr];
        Comm.ptr++;
    }
}


/*******************************************************************
* IRCommRX():  
********************************************************************/
void IRCommRX()
{
 register unsigned char i;

    if(ASIS0==0)
    {
        if(Comm.status == COMM_STATUS_FREE)
    	  {
    	      Comm.status = COMM_STATUS_URRX;
    	      Comm.ptr = 0;    
    	  }
    	  
    	  i = RXB0;
    	  
    	  if(Comm.status != COMM_STATUS_URRX)   return; 
        
        Comm.rsErrTmr = 0;
        if( Comm.ptr >= RTx_MaxSize)   return;
        Comm.commBuff[Comm.ptr] = i;
        
        if( Comm.commBuff[0] == 0x68)  
        {
            if( Comm.ptr > 10)
            {
                NOP();
                NOP();	
            }
            Comm.ptr++;
        
        }
        else
        {
            Comm.ptr = 0;	  
        }    
    
    } // end of "if(ASIS6==0)"                                
    else 
    {
        i=ASIS0;
        i=RXB0;
        Comm.status = COMM_STATUS_INIT;
    }// end of "if(ASIS6==0)  else " 
}

/*******************************************************************
* IRCommTX():  
********************************************************************/
void IRCommTX()
{
    STIF0=0;
    
    if(Comm.status & COMM_MODE_RS485)  return;
    
    Comm.rsErrTmr = 0;
    
    if(Comm.cntFE != 0)
    {
        TXS0 = 0xfe;
        Comm.cntFE--;
    }
    else
    {
        if((Comm.ptr >= RTx_MaxSize) || (Comm.ptr >=(char)(RS_MinSize+Rs_Len) ))  return; 
        TXS0 = Comm.commBuff[Comm.ptr];
        Comm.ptr++;
    }
}