general.c

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

/*******************************************************************
* general.c    :
********************************************************************/
#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"

/******************************************************************
*
*
*******************************************************************/
void Delay_ms(unsigned char j)
{
 register unsigned char _dcnt;
     while (--j !=0)
     {   
        _dcnt = 223; 
	while(--_dcnt != 0)
        {
            NOP();NOP();NOP();NOP();NOP();NOP();NOP();NOP();	         
	}
     }
    
}

/******************************************************************
*
*
*******************************************************************/
unsigned char Cmp_TwoArry(uchar* s1, uchar* s2, uchar len) 
{
    register unsigned char i;
    
    s1=s1+(char)(len-1);
    s2=s2+(char)(len-1);
    for (i=0; i<len;i++)
    {
        if((*s1) > (*s2))  return (1);
        if((*s1) < (*s2))  return (255);
        s1--;
        s2--;
    }
    return (0);
}

/******************************************************************
*实现数组顺序颠倒。
*  such as   A0A1A2A3 ---> A3A2A1A0;
*******************************************************************/
void Rev_Copy_Arry(uchar* s1, uchar len) 
{
    uchar tmpData;
    uchar i = len/2;

    for(i=0; i<len/2;i++)
    {
         *(s1+i) = tmpData;
         *(s1+i) = *(s1+len-i);
         *(s1+len-i) = tmpData;   
    }
}

/******************************************************************
*
*
*******************************************************************/
uchar Get_csckNum( uchar *Ptr, uchar Len )
{
 register unsigned char Num;
        
        Num = CHECKWORD;
        while( Len > 0 )
        {
            Num += *Ptr;
            Ptr++;
            Len--;
        }
        return Num;
}



/******************************************************************
*
*
*******************************************************************/
void Sys_err(void)
{
      while(1)
      continue;
}

/******************************************************************
*
*
*******************************************************************/
void CheckSystemSub(void)
{
 uchar tmp;
 uchar i;
 
    // energy measure parament check
    tmp = Get_csckNum((uchar*)&Sram.Adj_Base[0],2);
    if(tmp != Sram.Adj_BaseCK) 
    {
    	tmp =  Get_csckNum((uchar*)&Sram.Factor[0],2);
    	if(tmp != Sram.FactorCK)
    	{
    	    MEM_Read(E2P_EADJ, (uchar*)&Sram.Factor[0], 2);
    	}  
    	
    	for(i=0;i<1;i++) 
        {
              Sram.Adj_Base[i]=Sram.Factor[i];
        }
        Sram.FactorCK = Get_csckNum((uchar*)&Sram.Factor[0],2);
        Sram.Adj_BaseCK = Sram.FactorCK;
    }  
    
    // energy measure data check
    if(Sram.PLFCnt >(CONS_METER +2))   Sram.PLFCnt = (CONS_METER/2); 
    
    if(MDLoad.ptr >= 5)    MDLoad.ptr = 0;
}

/******************************************************************
*
*
*******************************************************************/
void SysReset()
{
     MEM_Write(E2P_TENDEC, (uchar*)&Sram.T_ENdec, 0x05);          //save energy data
     Sys_err();
}


/******************************************************************
*
*
*******************************************************************/
void Copy_Str_BNK0(char *s1, char *s2, char len) 
{
    while(len > 0)
    {
        *s1 =*s2;
        s1++;
        s2++;
        len--;
    }
}

/******************************************************************
*
*
*******************************************************************/
bit PowerCk(void)
{
    if(Flag.even & bitRly)   return (0);
    
    if(LVIF)
    {   
        Delay_ms(1);
        if(LVIF)
        {
            Delay_ms(1);
            if(LVIF)
            {
                return (1);
            }
        }  
    }
    return (0);
}


/**********************************************************************
 turn byte data to BCD data
**********************************************************************/
uchar Byte_BCD(uchar Data)
{
   if( Data > 99 ) return 0x00;
   return( Data/10*0x10 + Data%10 );
}

/**********************************************************************
 turn BCD data to byte data
**********************************************************************/
uchar BCD_Byte(uchar Data)
{
   return(((Data>>4)&0x0F)*10+(Data&0x0F));
}

//**********************************************************************
// turn word data to BCD2 data
//**********************************************************************
void Word_BCD2( uchar *Ptr, uint Data )
{
   if( Data > 9999 ) 
   {
      *(Ptr+1) = 0x00;
      *Ptr = 0x00;
      return;
   }

   *(Ptr+1) = Byte_BCD( (uchar)(Data/100) );
   *(Ptr) = Byte_BCD( (uchar)(Data%100) );
}

//**********************************************************************
// turn  BCD2 data to  word data 
//**********************************************************************
uint BCD2_Word(uchar* Ptr)
{
   return(  (uint)BCD_Byte(*Ptr)+
            (uint)BCD_Byte(*(Ptr+1))*100 );
}

//**********************************************************************
// turn long data to BCD4 data
//**********************************************************************
void Long_BCD4(uchar* Ptr, ulong Data)
{
	if( Data > 99999999 ) 
	{
      	*(Ptr+3) = 0x00;
      	*(Ptr+2) = 0x00;
      	*(Ptr+1) = 0x00;
      	*Ptr = 0x00;
      	return;
   	}
	Word_BCD2(Ptr+2, Data/10000);
	Word_BCD2(Ptr, Data%10000);
} 

//**********************************************************************
// turn BCD4 data to long data
//**********************************************************************
ulong BCD4_Long( uchar* Ptr )
{
	return ( BCD_Byte(*Ptr)+ (ulong)(BCD_Byte(*(Ptr+1)))*100+ (ulong)(BCD_Byte(*(Ptr+2)))*10000+(ulong)(BCD_Byte(*(Ptr+3)))*1000000 );
}


/******************************************************************
*
*
*******************************************************************/
void BCD1INC ( uchar* Temp )
{
	
	(*Temp)++;
	if( (*Temp & 0x0f) >= 0x0A )
	{
		(*Temp) &=~ 0x0f;
		*Temp+=0x10;
		if( ((*Temp>>4)&0x0f) >=0x0A ) *Temp =0;
	}
}


/******************************************************************
*
*
*******************************************************************/
void BCD1DEC( uchar* Temp )
{
	if( *Temp == 0x00 ) {*Temp=0x99;return ;}
	else
	{
		if( (*Temp & 0x0f) ==0 ) 
		{
			*Temp &=~ 0x0f;
			*Temp |= 0x09;
			*Temp -= 0x10;
		}
		else 
		{	
			(*Temp)--;
		}
	}
}
	
/******************************************************************
*
*
*******************************************************************/
uchar bcdINCAdj(uchar* ptr, uchar len)
{
  register unsigned char result;

    while(len > 0)
    {
    	result = 0;
    	BCD1INC (ptr);
    	if(*ptr != 0)  break;
        len--;
        ptr++;
        result=1;
    }
    return (result);
}


/******************************************************************
*
*
*******************************************************************/
uchar bcdDECAdj(uchar* ptr, uchar len)
{
  register unsigned char result;

    while(len > 0)
    {
    	result = 0;
    	BCD1DEC (ptr);
    	if(*ptr != 0x99)  break;
        len--;
        ptr++;
        result=1;
    }
    return (result);
}