protocol.c

NEC527多功能电表完整源代码,包括LCD驱动,显示,计量,存储,整个527驱动程序!

#include "includes.h"

unsigned long DI1DI0;
unsigned char FramePointer;
unsigned char DI0_H;
unsigned char DI0_L;
unsigned char SlvsClrStatus = 0;
unsigned char CommPortBak = 0;

typedef unsigned char (*COMM_PROC_PTR)(void);

unsigned char RxFrameDispose(void)
{
    if( CommPortChose & ( IR_PORT+RS485_PORT+RS485_2_PORT + ANA_UART_PORT ) )
    {
        if( FramePointer >= FRAME_BUFFER_LEN )
        {
            goto rxerror;
        }
        
        FrameBuffer[FramePointer++] = UartRxByte;
        _wait_time = COMM_TIMEOUT;
        
        if( FrameBuffer[0] != FRAME_START_FLAG )
        {
            goto rxerror;
        }

        if( FramePointer > FRM_STOP_BYTE )
        {
            CommPortChose |= COMM_RX_FINISH;
            CommPortBak = CommPortChose;			
            SYS_EVT_ADD( EVT_COMM );
            return OK;
        }
    }
    	
    return ERROR;    
	
rxerror:	
    FramePointer = 0;
    _wait_time = 0;
    CommPortChose = 0;	

    return ERROR;
}


unsigned char FindCmdItem(const unsigned char *cmd,unsigned char ctlw)
{
    unsigned char i=0;
    	
    while(*(cmd+i)!=ERROR)
    {
        if(*(cmd+i)==ctlw)
        {
            return i;
        }
        i++;
    }
    return ERROR;
}

/*************************************************
 * 比对从机地址
 *************************************************/
unsigned char CompSlvsAddr(void)
{
    unsigned char ucaTemp[FRM_ADDR_LEN],i;

    FramRead(ADDR_OF_METER_NUM, ucaTemp, FRM_ADDR_LEN);

    if(IsEqual(&FrameBuffer[FRM_ADDR],ucaTemp,FRM_ADDR_LEN)==OK)  
    {
        return COM_ATTRIBUTE_SINGLE;
    }
    else if(IsEqualSpecialData(&FrameBuffer[FRM_ADDR],0x99,FRM_ADDR_LEN)==OK) 
    {
        return COM_ATTRIBUTE_BROADCAST;
    }
    else
    {
        for( i = 5; i >= 1; i-- ) 
        {
            if( FrameBuffer[FRM_ADDR+i] != 0xAA ) break;
        }
		
        if( IsEqual( &FrameBuffer[FRM_ADDR], &ucaTemp[0], i+1 ) == OK )
        {
            return COM_ATTRIBUTE_SINGLE;    
        }
    }	 	

    return ERROR;
}

const unsigned char _factory_password1[]={0x10,0x05,0x82};
const unsigned char _factory_password2[]={0x68,0x79,0x79};
unsigned char CheckSlvsPwd(unsigned char *pucData,unsigned char item)
{
    unsigned char ucaTemp[4];
    
    if( item == 0 )
    {
        return( IsEqual( (unsigned char *)&_factory_password1[0], pucData, 3 ) );
    }
    else if( item <= 3 )
    {
        FramRead( ADDR_OF_METER_PASSWORD1+(item-1)*4+1, ucaTemp, 3 );
        return( IsEqual( &ucaTemp[0], pucData, 3 ) );
    }		
    else if( item == 4 )
    {
        return ( IsEqual( (unsigned char *)&_factory_password2[0], pucData, 3 ) );
    }
	
    return ERROR;
}

void ResetClearStatusWord(void)
{
    SlvsClrStatus=0;
}

static unsigned char __SlvsReadProc70_1_xx(void)
{
    unsigned char di1,i;

    di1 = FrameBuffer[DI1] & 0x0F;
    FrameBuffer[FRM_DATALEN] = 4;

    if( DI0_L < 5 )
    {
        if( DI0_H <= 6 )
        {
            DI1DI0 = ADDR_OF_FED_BASE+( di1*15+DI0_H*5+DI0_L )*4;
            return( RET_SEND_RIGHT_RESPONSION | RET_READ_E2PROM_A );        
        }
    }
    else if( DI0_L == 0x0F )
    {
        if( DI0_H <= 6 )
        {
            for( i = 0; i < 5; i++ )
            {
                DI1DI0 = ADDR_OF_FED_BASE+( di1*15+DI0_H*5+i )*4;
                FramRead((ushort)DI1DI0, &FrameBuffer[FRM_DATA+2+i*4], 4 );
            }            			
        }
        MemSet0xFF( &FrameBuffer[FRM_DATA+22], 40 );
        FrameBuffer[FRM_DATA+62] = 0xAA;
        FrameBuffer[FRM_DATALEN] = 61;
        return RET_SEND_RIGHT_RESPONSION;		
    }

    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;
}

static unsigned char __SlvsReadProc7_2_F_xx(void)
{
    unsigned char item,temp,mon;
    unsigned char di0_l = DI0_L,di0_h = DI0_H,i;

    temp = (FrameBuffer[DI1]>>4);

    if( temp == 7 )
    {
        mon = ( ( FrameBuffer[DI1] & 0x0F ) >> 1 )+5;
    }
    else
    {
        goto ReadProc7_2_F_xx_ERROR;
    }
	        	
    FrameBuffer[FRM_DATALEN] = 4;
    temp =  ( FrameBuffer[DI1] & 0x0F ) % 2;
    if( di0_h <= 0x06 )
    {
        item = temp*15+di0_h*5;
        if( di0_l < 5 )
        {                
            LoadEnergy( &FrameBuffer[FRM_DATA+2], mon, item+di0_l );
            return(RET_SEND_RIGHT_RESPONSION);				
        }
        else if( di0_l == 0x0F )
        {
            for( i = 0; i < 5; i++ )
            {
                LoadEnergy( &FrameBuffer[FRM_DATA+2+i*4], mon, item+i );					
            }
            for( i = 0; i < 40; i++ )
            {
                FrameBuffer[FRM_DATA+22+i] = 0xFF;
            }
            FrameBuffer[FRM_DATA+62] = 0xAA;
            FrameBuffer[FRM_DATALEN] = 61;
            return(RET_SEND_RIGHT_RESPONSION);								
        }
    }    

ReadProc7_2_F_xx_ERROR:
    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;
}

const unsigned char phase_power_item[]={0,4,8,1,5,9,2,6,10,3,7,11};
static unsigned char _SlvsReadProc9AB_014589_xx(void)
{
    unsigned char item,temp,mon;
    unsigned char di0_l=DI0_L,di0_h=DI0_H;

    if( ( FrameBuffer[DI1] == 0x91 ) && ( di0_h == 0x0E ) )
    {
        goto __SlvsReadProc91_Ex_END;
    }

    temp=( FrameBuffer[DI1] >> 4 )-9;
    if( di0_h == 0 )
    {
        item=temp*50+(FrameBuffer[DI1]&0x01)*15;		
        if( di0_l < 5 )
        {
            item+=di0_l;
            goto ___SlvsReadProc9AB_014589_xx_END;
        }
        else if( di0_l == 0x0F )
        {
            goto ___SlvsReadProc9AB_014589_xx_END;
        }
    }
    else if( di0_h <= 2 )
    {
        item=(temp*50)+(FrameBuffer[DI1]&0x01)*15+di0_h*5;
        if(di0_l<5)
        {
            item+=di0_l;
            goto ___SlvsReadProc9AB_014589_xx_END;
        }
        else if(di0_l==0x0F)
        {
            goto ___SlvsReadProc9AB_014589_xx_END;
        }
    }
    else if(di0_h<=6)
    {
        item=(temp*50)+30+(di0_h-3)*5;
        if(di0_l<5)
        {
            item+=di0_l;
            goto ___SlvsReadProc9AB_014589_xx_END;
        }		
        else if(di0_l==0x0F)
        {
            goto ___SlvsReadProc9AB_014589_xx_END;
        }
    }
	
    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;
    
___SlvsReadProc9AB_014589_xx_END:
    if( ( FrameBuffer[DI1] & 0x0F ) <= 8 )
    {
        mon = (FrameBuffer[DI1]&0x0F)>>2;
    }
    else
    {
        mon = (FrameBuffer[DI1]&0x0F)/2-2;
    }
    FrameBuffer[FRM_DATALEN]=MON_OFFSET1;
    if(temp==0)
    {
        if(di0_l==0x0F)
        {
            FrameBuffer[FRM_DATALEN] = 61;
            for( temp = 0; temp < 5; temp++ )
            {
                LoadEnergy( &FrameBuffer[FRM_DATA+2+temp*4], mon, item+temp );
            }
            MemSet0xFF( &FrameBuffer[FRM_DATA+22], 40 );			
            FrameBuffer[FRM_DATA+62] = 0xAA;
        }
        else
        {
            LoadEnergy(&FrameBuffer[FRM_DATA+2],mon,item);
        }
    }
    else 
    {
        if((item<100)&&(item>=50)) FrameBuffer[FRM_DATALEN]=3;
        if(di0_l==0x0F)
        {
            for(temp=0;temp<5;temp++)
            {
                LoadMaxDemandInfo(&FrameBuffer[FRM_DATA+2+temp*FrameBuffer[FRM_DATALEN]],mon,item+temp);
            }			
            for( temp = 0; temp < FrameBuffer[FRM_DATALEN]*10; temp++ )
            {
                FrameBuffer[FRM_DATA+2+FrameBuffer[FRM_DATALEN]*5+temp] = 0xFF;
            }
            FrameBuffer[FRM_DATALEN]*=15;
            FrameBuffer[FRM_DATA+2+FrameBuffer[FRM_DATALEN]] = 0xAA;			
            FrameBuffer[FRM_DATALEN]+=1;            			
        }
        else
        {
            LoadMaxDemandInfo(&FrameBuffer[FRM_DATA+2],mon,item);
        }
    }    
    return(RET_SEND_RIGHT_RESPONSION);

__SlvsReadProc91_Ex_END:
    if( di0_l <= 12 )
    {
        FrameBuffer[FRM_DATALEN] = 48;
        for( temp = 0; temp < 12; temp++ )
        {
            LoadPhasePowerData( (unsigned char *)&FrameBuffer[FRM_DATA+2+temp*4], di0_l, phase_power_item[temp] );
        }            
        return(RET_SEND_RIGHT_RESPONSION);    
    }
    else if( di0_l == 0x0D )
    {
        FrameBuffer[FRM_DATALEN] = 48;
        DI1DI0 = ADDR_OF_FED_BASE + FED_PHASE_ENERGE;
        return(RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A);
    }        
    
    FrameBuffer[FRM_DATA] = RET_ERR_ID;
    return RET_SEND_ERROR_RESPONSION;
}

const unsigned short _SlvsReadProcB21x_addr[]=
{
    ADDR_OF_PROG_REC,
    ADDR_OF_REQ_CLR_REC,
    ADDR_OF_PROG_REC,
    ADDR_OF_REQ_CLR_REC    
};
const unsigned char _SlvsReadProcB21x_len[]={4,4,2,2};

static unsigned char _SlvsReadProcB2xx(void)
{
    unsigned long temp1, temp2;
    unsigned short count;
    unsigned char i;
 	
    if( DI0_H == 0x01 )
    {
        if( DI0_L <= 0x03 )
        {
            if( DI0_L <= 0x01 )
            {
                DI1DI0 = _SlvsReadProcB21x_addr[DI0_L]+2;
            }
            else
            {
                DI1DI0 = _SlvsReadProcB21x_addr[DI0_L];
            }
            FrameBuffer[ FRM_DATALEN ] = _SlvsReadProcB21x_len[ DI0_L ];
            return(RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A);
        }
        else if( DI0_L == 0x04 )
        {
            FramRead(ADDR_OF_BATTERY_RUNTIME,(unsigned char *)&temp1,3);
            if(PowerStateFlag&PS_BREAKPOWER_FLAG)
            {
                temp2=CalcPastTime(TMPT_BASE+TMPT_POWER_DOWN);
                temp1=__bcd_add_long(temp1,temp2);
            }
            memcpy((unsigned char *)&FrameBuffer[FRM_DATA+2],(unsigned char *)&temp1,3);
            FrameBuffer[FRM_DATALEN]=3;
            return(RET_SEND_RIGHT_RESPONSION);        
        }
        else if( DI0_L == 5 )		
        {
            FramRead(ADDR_OF_METER_RUNTIME,(unsigned char *)&temp1,4);
            temp2=CalcPastTime(TMPT_BASE+TMPT_METER_RUN);
            temp1=__bcd_add_long(temp1,temp2);
            memcpy((unsigned char *)&FrameBuffer[FRM_DATA+2],(unsigned char *)&temp1,4);
            FrameBuffer[FRM_DATALEN]=4;
            return(RET_SEND_RIGHT_RESPONSION);  		
        }
        else if( DI0_L == 0x0F )
        {
            for( i = 0; i < 2; i++ )
            {
                FramRead( _SlvsReadProcB21x_addr[i]+2, &FrameBuffer[FRM_DATA+2+i*4], 4 );
                FramRead( _SlvsReadProcB21x_addr[i], &FrameBuffer[FRM_DATA+10+i*2], 2 );   
            }
			
            FramRead(ADDR_OF_BATTERY_RUNTIME,(unsigned char *)&temp1,3);
            if(PowerStateFlag&PS_BREAKPOWER_FLAG)
            {
                temp2=CalcPastTime(TMPT_BASE+TMPT_POWER_DOWN);
                temp1=__bcd_add_long(temp1,temp2);
            }
            memcpy((unsigned char *)&FrameBuffer[FRM_DATA+14],(unsigned char *)&temp1,3);
            FrameBuffer[FRM_DATA+17] = 0xAA;
            FrameBuffer[FRM_DATALEN] = 16;			
            return(RET_SEND_RIGHT_RESPONSION);
        }		
    }
	
    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;		
}

const unsigned short _SlvsReadProcB3xx_addr[]={
    ADDR_OF_LOST_COUNT,
    ADDR_OF_LOST_LONG, 
    ADDR_OF_LOST_TIME,
    ADDR_OF_LOST_TIME+16
};
const unsigned char _SlvsReadProcB3xx_len[]={ 2, 3, 4, 4 };	
static unsigned char __SlvsReadProcB3xx(void)
{
    unsigned char di0_h = DI0_H-1,di0_l = DI0_L;

    if( di0_h <= 0x01 )
    {
        if( di0_l <= 0x03 )
        {
            DI1DI0 = _SlvsReadProcB3xx_addr[di0_h]+di0_l*_SlvsReadProcB3xx_len[di0_h];
            FrameBuffer[FRM_DATALEN] = _SlvsReadProcB3xx_len[di0_h];
            return(RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A);				
        }
        else if( di0_l == 0x0F )
        {