comm.c

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

/*
************************************************************************
* Comm.C   :DL645 communication programme
* 
********************************************************************
*/

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

#include "include\FunAnnounce.h"




/*******************************************************************
* uchar MeteIDCheck():
********************************************************************/
uchar MeteIDCheck(void)
{
     register uchar i;
     uchar *ptr;
     uchar adr[6];
    
    
     MEM_Read(E2P_ID, &adr[0], 6);

     ptr = &Rs_Head0;
     //
     for(i=6; i>0; i--)
     {
         if( *(ptr-i) !=0x99)  break;
     }
     if(i==0)       return(1); 
 
     //
     for(i=6; i>0; i--)
     {
        if( ( *(ptr-i) != 0xaa ) && ( *(ptr-i) != adr[6-i] ) ) 
        {
            return(0);
        } 
     }   
     return(1); 
}

/*****************************************************************
 name:          uchar SecurityCK(uchar type)
 function:      operate  Security check
 input:         no            
 return:        SecurityCK()
                =mmok    succeed  precess 
                =mmerr   error passworsd
                =uferr   Security level illegal 
*****************************************************************/
uchar SecurityCK(uchar type)
{
    uchar userStatus;
    uchar ary[4];
    
    //super level control
    if (pin_KEYCHK==0)       return (mmok);

    //password check
    MEM_Read(E2P_MM0, &ary[0], 4);          //get level 0 password
    switch  (type)
    {
        case W_MM>>8:                              
            if ( Cmp_TwoArry( &Rs_Data, &ary[0], 4) !=0)  return(mmerr);
            break;
        case  W_HKEY>>8:   
            if((Flag.even & bitPGKen) != 1)   return(mmover); 
            if ( Cmp_TwoArry( &Rs_Data, &ary[0], 4) !=0)  return(mmerr);    
            break;	
			
        case  W_FCT>>8:                          
             return(uferr); 
					  			
        case 0x20:              
            if (Rs_IDL < Rs_Data3)    return(mmover); 
            if ( Cmp_TwoArry( &Rs_IDH, &ary[1], 3) != 0)    return(mmerr);
            break;            
  
        default:  
            Sys_err(); 
            break;
    }
    
    return (mmok);
}



/*****************************************************************
 name:          uchar  GetComVar( uchar* Addr, uint* Info )
 function:      get command information precess  
 input:         no            
 return:        GetComVar()
                =0    succeed  precess 
                =1    fail precess 
*****************************************************************/
uchar  GetComVar( uint* Addr, uint* Info )
{
    uint Tmp;
    uchar i;  

    Tmp = ((int)Rs_IDH<<8)+ (int)Rs_IDL;
    for( i = 0 ; i < ComDisNum ; i++ )
    {
        if( Tmp == ComDisTab[i].ComID )
        {
            *Addr = ComDisTab[i].Addr;
            *Info = ComDisTab[i].ComInfo;
            return 1;
	}
    }
    return 0;
}


/*****************************************************************
 name:          uchar Com_Read(void)
 function:      reading modul precess
 input:         no            
 return:        SecurityCK()
                =mmok    succeed  precess 
                =mmerr   error passworsd
                =uferr   Security level illegal 
*****************************************************************/
uchar Com_Read(void)
{
   uint    Addr;
   uint     Info;
   uint     commID;
   uchar    Len;
   uchar    i;

    commID = ((int)Rs_IDH<<8)+ (int)Rs_IDL;
    if( GetComVar( &Addr, &Info ) == 0 )   return(RS_State_IVID);   


    if( ( Info & EN_R ) == 0 )   return(RS_State_IVID);  

    Len =  *((char*)(&Info)) ;
    Len &=UR_LEN;                         
	

    for(i=0;i<Len;i++)
    {
        Comm.commBuff[RS_DPtr+i]= 0;
    }  
    Rs_Len = Len+2;
				
    switch ( Info & UR_TESHU )  
    {    
        case CM_GEN:                           
            MEM_Read(Addr, &Rs_Data, Len); 
            break; 
			
        case UR_TEC:                           
            MEM_Read(E2P_TENINT, &Rs_Data, 0x04);
            Comm.commBuff[RS_DPtr]= Sram.T_ENdec;   
            break;  

        case UR_REC:                           
            MEM_Read(E2P_RENINT, &Rs_Data, 0x04);
            Comm.commBuff[RS_DPtr]= Sram.R_ENdec;   
            break ;	

        case UR_LEC:                           
            MEM_Read(E2P_LENINT, &Rs_Data, 0x04);
            Comm.commBuff[RS_DPtr]= Sram.L_ENdec;   
            break;  

        case UR_POWER:                           
            Comm.commBuff[RS_DPtr]= MDLoad.mpower[0];   
            Comm.commBuff[RS_DPtr+1]= MDLoad.mpower[1];   
            Comm.commBuff[RS_DPtr+2]= MDLoad.mpower[2];   
            break;  

        case UR_DLYS:                          
            Comm.commBuff[RS_DPtr]= 0x0f;
            if(Flag.prepay&bitP_delayON)    Comm.commBuff[RS_DPtr]= 0x00;
            break ;

        case UR_MCER:                          
            Comm.commBuff[RS_DPtr]= Sram.SYSErr_status;
            break ;

        case UR_CONST:                           
            Comm.commBuff[RS_DPtr+1]= CONDIS_METER;   
            break  ;

        case UR_ZEC:                           
            MEM_Read(E2P_ZENINT, &Rs_Data, 0x04);
            Comm.commBuff[RS_DPtr]= Sram.Z_ENdec;   
            break;  

	case UR_TESHU:	
            if(commID==0xc712)              
           {
                for(i=0;i<16;i++)
               {
                      Comm.commBuff[RS_DPtr+i]= video[15-i];
                }       
                Rs_Len = Len+2;
                return(RS_State_OK);                               
            }

	    return(RS_State_IVID); 

        default:  
            return(RS_State_IVID);                           
    }     
		
    return(RS_State_OK); 
}



/*****************************************************************
 name:          uchar Com_Write(void)
 function:      program modul precess
 call:          SecurityCK()
                MEM_Write()
                Copy_Str_BNK0()
 by call:       RsCommSub()  
 input:         no            
 return:        Com_changeMM()
                =RS_State_OK       succeed opration
                =RS_State_NOres    no responsion
*****************************************************************/
uchar Com_Write(void)
{
  uint     commID; 
  uint    Addr;
  uint     Info;
  uchar	   Len;
  uchar    secType;
  uchar   tmp00;  
  uchar   tmp01;
  uchar   data[8];
  
    
    commID = ((uint)Rs_IDH<<8)+ (uint)Rs_IDL;
    if( GetComVar( &Addr, &Info ) == 0 )   return(RS_State_IVID);
    if( ( Info & EN_W ) == 0 )  return(RS_State_IVID);
    Len= *((char*)(&Info)) & UR_LEN;
    if(Rs_Len != (Len+6) )  return(RS_State_IVID);
    
    //security check program
    secType = (*((char*)(&Info)+1) & (W_FCT>>8));             //
    //secType = secType >>4;                                    //
    secType = SecurityCK(secType);

    if(secType == mmerr)   return(RS_State_PswE);
    if(secType != mmok)  return(RS_State_IVID);


    switch(Info & UR_TESHU)
    {
        case CM_GEN:
	     MEM_Write( Addr, &Rs_WData, Len);
	     break;

        case UW_ECINIT:
	     if(Comm.commBuff[16] != 0)    return(RS_State_IVData);
            if(Comm.commBuff[17] != 0)    return(RS_State_IVData);
            if(Comm.commBuff[18] != 0)    return(RS_State_IVData);
            if(Comm.commBuff[19] != 0)    return(RS_State_IVData);	

            MEM_Write( E2P_TENINT, &Rs_WData, 0x04);               // clear total use energy data
            MEM_Write( E2P_RENINT, &Rs_WData, 0x04);               // clear REV  energy data            
            MEM_Write( E2P_ZENINT, &Rs_WData, 0x04);               // clear OVER ZERO energy data
            data[0] = 0x00;
            data[1] = 0x10;
            data[2] = 0x00;
            data[3] = 0x00;
            MEM_Write( E2P_LENINT, &data[0], 0x04);                   // SET LEAVE energy data FOR 10.00kWh
            MEM_Write( E2P_SUMBUY, &data[0], 0x04);                 // SET total buy  energy data FOR 10.00kWh
            MEM_Write( E2P_BUY1, &data[0], 0x04);                    // SET last time buy energy data FOR 10.00kWh
 
            Sram.T_ENdec = 0;
            Sram.R_ENdec = 0;
            Sram.L_ENdec = 0;
            Sram.Z_ENdec = 0;
            Sram.PLFCnt= 0;
		   
            MEM_Write( E2P_CNTEIC, &data[0], 0x01);                   // SET card error use time is 0 
            data[0] = 0x01;
            data[1] = 0x00;
            MEM_Write( E2P_BUYCNT, &data[0], 0x02);                   // SET buy energy  times if 1

            break;

        default:
             return(RS_State_IVData);
    }
      
     return(RS_State_OK);  
}


/*****************************************************************
 name:          uchar Com_changeMM(void)
 function:      change meter password
 call:          SecurityCK()
                MEM_Write()
                Copy_Str_BNK0()
 by call:       RsCommSub()  
 input:         no            
 return:        Com_changeMM()
                =RS_State_OK       succeed opration
                =RS_State_NOres    no responsion                                          
*****************************************************************/
uchar Com_changeMM(void)
{     
    // judge data length