protocol.c

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

            DI1DI0 = ADDR_OF_VOL_SEQERR_REC+VOL_SEQERR_REC_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = VOL_SEQERR_REC_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A ); 			
        }
    }
    else if( DI0_H == 0x0C )
    {
        if( DI0_L <= 0x09 )
        {
            DI1DI0 = EVT_VOL_SEQERR_BASE+EVT_VOL_SEQERR_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = EVT_VOL_SEQERR_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );			
        }
    }
#if 0
    else if( DI0_H == 0x0D )
    {
        if( DI0_L <= 0x04 )
        {
            DI1DI0 = ADDR_OF_CUR_SEQERR_REC+CUR_SEQERR_REC_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = CUR_SEQERR_REC_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );
        }
    }
    else if( DI0_H == 0x0E )
    {
        if( DI0_L <= 0x09 )
        {
            DI1DI0 = EVT_CUR_SEQERR_BASE+EVT_CUR_SEQERR_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = EVT_CUR_SEQERR_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );			
        }    
    }
#endif
    else if( DI0_H == 0x0D )
    {
        if( DI0_L <= 0x04 )
        {
            DI1DI0 = ADDR_OF_WATT_REVERSE_REC+WATT_REVERSE_REC_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = WATT_REVERSE_REC_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );
        }
    }
    else if( DI0_H == 0x0E )
    {
        if( DI0_L <= 0x09 )
        {
            DI1DI0 = EVT_WATT_REVERSE_BASE+EVT_WATT_REVERSE_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = EVT_WATT_REVERSE_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );			
        }    
    }

    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;
}

static unsigned char _SlvsReadProcE3xx(void)
{	
    unsigned char count;
	
    if( DI0_H == 0x01 )
    {
        if( DI0_L == 0x00 )
        {
            DI1DI0 = EVT_REC_SET_TIME_BASE;
            FrameBuffer[FRM_DATALEN] = 2;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );            			
        }
        else if( DI0_L <= 0x0A )
        {
            DI1DI0 = EVT_REC_SET_TIME_BASE+2+EVT_REC_SET_TIME_OFFSET*(DI0_L-1);
            FrameBuffer[FRM_DATALEN] = EVT_REC_SET_TIME_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );           			
        }
    }
    else if( DI0_H == 0x02 )
    {
        if( DI0_L == 0x00 )
        {
            DI1DI0 = ADDR_OF_CLR_POWERDATA_COUNT;
            FrameBuffer[FRM_DATALEN] = CLR_POWERDATA_COUNT_SIZE;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );            			
        }
        else if( DI0_L <= 0x0A )
        {
            count = ReadTimesMod10( ADDR_OF_CLR_POWERDATA_COUNT );
            DI1DI0 = EVT_REC_DATA_CLR_BASE+DF_PAGE_LEN*(count/5);
            if( DI0_L-1 <= count ) count = count+1-DI0_L;
            else count = count+11-DI0_L;
            DI1DI0 = EVT_REC_DATA_CLR_BASE+DF_PAGE_LEN*(count/5)+EVT_REC_DATA_CLR_OFFSET*(count%5);
            FrameBuffer[FRM_DATALEN] = EVT_REC_DATA_CLR_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );           			
        }    
    }
    else if( DI0_H == 0x03 )
    {
        if( DI0_L == 0x00 )
        {
            DI1DI0 = ADDR_OF_REQ_CLR_COUNT;
            FrameBuffer[FRM_DATALEN] = REQ_CLR_COUNT_SIZE;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );           						
        }
        else if( DI0_L <= 0x0A )
        {
            DI1DI0 = EVT_REC_REQ_CLR_BASE+EVT_REC_REQ_CLR_OFFSET*(DI0_L-1);
            FrameBuffer[FRM_DATALEN] = EVT_REC_REQ_CLR_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V ); 			
        }
    }
    else if( DI0_H == 0x05 )
    {
        if( DI0_L == 0x00 )
        {
            DI1DI0 = ADDR_OF_PROG_COUNT;
            FrameBuffer[FRM_DATALEN] = PROG_COUNT_SIZE;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );			
        }
        else if( DI0_L <= 0x0A )
        {
            DI1DI0 = EVT_REC_PROG_BASE+EVT_REC_PROG_OFFSET*(DI0_L-1);
            FrameBuffer[FRM_DATALEN] = EVT_REC_PROG_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );			
        }
    }
    else if( DI0_H == 0x06 )
    {
        if( DI0_L == 0x00 )
        {
            DI1DI0 = ADDR_OF_PD_COUNT;
            FrameBuffer[FRM_DATALEN] = PD_COUNT_SIZE;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );
        }
        else if( DI0_L <= 0x0A )
        {
            DI1DI0 = ADDR_OF_PD_TIME+PD_TIME_OFFSET*(DI0_L-1);
            FrameBuffer[FRM_DATALEN] = PD_TIME_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );            			
        }
    }
    else if( DI0_H == 0x07 )
    {
        if( DI0_L <= 0x04 )
        {
            DI1DI0 = ADDR_OF_CURRENT_OVER+CURRENT_OVER_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = CURRENT_OVER_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A );			
        }
    }
    else if( ( DI0_H <= 0xA ) && ( DI0_H >= 0x08 ) )
    {
        if( DI0_L <= 0x09 )
        {
            DI1DI0 = EVT_OI_REC_BASE+EVT_OI_REC_LEN*(DI0_H-8)+EVT_OI_REC_OFFSET*DI0_L;
            FrameBuffer[FRM_DATALEN] = EVT_OI_REC_OFFSET;
            return( RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V );	
        }	
    }    
	
    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;
}

static unsigned char _SlvsReadProcE4xx(void)
{
    unsigned long vok_long[3], temp, s_long;
    unsigned long ovup_long[4],lvdo_long[4];
    unsigned short addr;
    unsigned char i;	
	
    if( DI0_H <= 0x04 )
    {
        addr = ADDR_OF_VOLTAGE_INFO+VOLTAGE_INFO_OFFSET*DI0_H;
        MemSetZero( (unsigned char *)&vok_long[0], 12 );
        MemSetZero( (unsigned char *)&ovup_long[0], 16 );
        MemSetZero( (unsigned char *)&lvdo_long[0], 16 );
        if( DI0_L <= 0x0B )
        {
            // 合格电压时间        
            for( i = 0; i < 3; i++ )
            {
                FramRead( addr+VOLTAGE_VOK_POSITION+i*3, (unsigned char *)&vok_long[i], 3 );
                vok_long[i] = Bcd2HexLong( vok_long[i] );
            }				

            // 电压超上限时间			
            for( i = 0; i < 4; i++ )
            {
                FramRead( addr+VOLTAGE_OVUP_POSITION+i*3, (unsigned char *)&ovup_long[i], 3 );
                ovup_long[i] = Bcd2HexLong( ovup_long[i] );				
            }

            // 电压超下限时间
            for( i = 0; i < 4; i++ )
            {
                FramRead( addr+VOLTAGE_LVDO_POSITION+i*3, (unsigned char *)&lvdo_long[i], 3 );
                lvdo_long[i] = Bcd2HexLong( lvdo_long[i] );
            }
			
            if( DI0_H == 0x00 )
            {
                for( i = 0; i < 3; i++ )
                {
                    if( VStateWord & ( PS_LVDO_PHA << i ) )
                    {
                        temp = CalcPastTime( TMPT_BASE+TMPT_LVDO_PHA+TMPT_OFFSET*i );
                        temp = Bcd2HexLong( temp );						
                        lvdo_long[i+1] += temp;
                        lvdo_long[0] += temp;
                    }
                    else if( VStateWord & ( PS_OVUP_PHA << i ) )
                    {
                        temp = CalcPastTime( TMPT_BASE+TMPT_OVUP_PHA+TMPT_OFFSET*i );
                        temp = Bcd2HexLong( temp );				
                        ovup_long[i+1] += temp;
                        ovup_long[0] += temp;
                    }
                    else
                    {
                        temp = CalcPastTime( TMPT_BASE+TMPT_VOK_PHA+TMPT_OFFSET*i );
                        temp = Bcd2HexLong( temp );						
                        vok_long[i] += temp;
                    }
                }						
            }
			
            if( DI0_L == 0x00 )
            {
                temp = (vok_long[0]+vok_long[1]+vok_long[2] )*10000;
                s_long = vok_long[0]+vok_long[1]+vok_long[2]+ovup_long[0]+lvdo_long[0];
                if( s_long != 0 ) temp = Hex2BcdLong( temp/s_long );
                else temp = 0;
                memcpy( &FrameBuffer[FRM_DATA+2], (unsigned char *)&temp, 3 );
                FrameBuffer[FRM_DATALEN] = 3;
            }
            else if( DI0_L < 4 )
            {
                temp = vok_long[DI0_L-1]*10000;
                s_long = vok_long[DI0_L-1]+ovup_long[DI0_L]+lvdo_long[DI0_L];
                if( s_long != 0 ) temp = Hex2BcdLong( temp/s_long );
                else temp = 0;				
                memcpy( &FrameBuffer[FRM_DATA+2], (unsigned char *)&temp, 3 );
                FrameBuffer[FRM_DATALEN] = 3;				
            }
            else if( DI0_L < 8 )
            {
                ovup_long[DI0_L-4] = Hex2BcdLong( ovup_long[DI0_L-4] );
                memcpy( &FrameBuffer[FRM_DATA+2], (unsigned char *)&ovup_long[DI0_L-4], 3 );
                FrameBuffer[FRM_DATALEN] = 3;				
            }
            else if( DI0_L < 0x0C )
            {
                lvdo_long[DI0_L-8] = Hex2BcdLong( lvdo_long[DI0_L-8] );
                memcpy( &FrameBuffer[FRM_DATA+2], (unsigned char *)&lvdo_long[DI0_L-8], 3 );
                FrameBuffer[FRM_DATALEN] = 3;				            
            }
            else
            {
                return RET_NO_RESPONSION;
            }
        }
    }
    else
    {
        FrameBuffer[FRM_DATA] = RET_ERR_ID;	
        return RET_SEND_ERROR_RESPONSION;
    }
	
    return RET_SEND_RIGHT_RESPONSION;
}

static unsigned char _SlvsReadProcE5xx(void)
{
    unsigned char hour,day,mon,year,ii;
    
    if( DI0_H == 0x00 )
    {
        hour = Bcd2HexChar( FrameBuffer[FRM_DATA+2] ); 
        day = Bcd2HexChar( FrameBuffer[FRM_DATA+3] );
        mon = Bcd2HexChar( FrameBuffer[FRM_DATA+4] );    
        FrameBuffer[FRM_DATALEN] = 35;
        if( day != Bcd2HexChar( _SysPotInfo.load_represet_day ) )
        {
            MemSetZero( (unsigned char *)&FrameBuffer[FRM_DATA+5], 30 );
            return(RET_SEND_RIGHT_RESPONSION);   
        }
        else
        {
            DI1DI0 = LOAD_RESPRESET_DAY_BASE + DF_PAGE_LEN * ( ( mon-1 ) * 2 + hour/12 ) + (unsigned short)hour * OFFSET_LOAD_RESPRESET_DAY;
            DataflashReadByBuffer1( DI1DI0, (unsigned char *)&pub_data.pub_data_buff3[0], OFFSET_LOAD_RESPRESET_DAY );
            for( ii = 0; ii < 10; ii++ )
            {
                memcpy( (unsigned char *)&FrameBuffer[FRM_DATA+5+ii*3], (unsigned char *)&pub_data.pub_data_buff3[ii*4], 3 );
            }
            return(RET_SEND_RIGHT_RESPONSION);
        }    
    }
    else if( DI0_H == 0x01 )
    {
        FrameBuffer[FRM_DATALEN] = 20;
        if( IsEqual( (unsigned char *)&SystemTime[SPACE_OF_DAY], (unsigned char *)&FrameBuffer[FRM_DATA+2], 3 ) == OK ) 
        {
            DI1DI0 = ADDR_OF_DAY_DATA_START + DAY_PHVA_INFO + DAY_PH_OFFSET * DI0_L;
            FramRead( (unsigned short)DI1DI0, (unsigned char *)&FrameBuffer[FRM_DATA+5], DAY_PH_OFFSET );
        }
        else
        {        
            DI1DI0 = GetDayAddr( FrameBuffer[FRM_DATA+4], FrameBuffer[FRM_DATA+3], FrameBuffer[FRM_DATA+2] );
            DI1DI0 += ( DAY_PHVA_INFO + DAY_PH_OFFSET * DI0_L );
            DataflashReadByBuffer1( DI1DI0, (unsigned char *)&FrameBuffer[FRM_DATA+5], DAY_PH_OFFSET );
        }
        return(RET_SEND_RIGHT_RESPONSION);        
    }
    else if( DI0_H == 0x02 )
    {
        FrameBuffer[FRM_DATALEN] = 19;
        if( ( _SysPotInfo.year == FrameBuffer[FRM_DATA+3] ) && ( _SysPotInfo.mon == FrameBuffer[FRM_DATA+2] ) )
        {
            FramRead( ADDR_OF_MON_DATA_START+(ushort)DI0_L*MON_PH_OFFSET, (unsigned char *)&FrameBuffer[FRM_DATA+4], MON_PH_OFFSET ); 
        }
        else
        {
            mon = Bcd2HexChar( FrameBuffer[FRM_DATA+2] );
            year = Bcd2HexChar( FrameBuffer[FRM_DATA+3] );
            year %= 10;
            DI1DI0 = YEAR_BASE + (ulong)(((year*12)+mon)*2)*DF_PAGE_LEN+MON_PH_DATA_INFO+(ushort)DI0_L*MON_PH_OFFSET;
            DataflashReadByBuffer1( DI1DI0, (unsigned char *)&FrameBuffer[FRM_DATA+4], MON_PH_OFFSET );
        }
        return(RET_SEND_RIGHT_RESPONSION);                		
    }

    FrameBuffer[FRM_DATA] = RET_ERR_ID;
    return RET_SEND_ERROR_RESPONSION;
}

static unsigned char _SlvsReadProcE8xx(void)
{
    unsigned char item;
    switch(FrameBuffer[DI0])
    {
        case 0x02:          
            item=FindCmdItem(_att702x_wr,FrameBuffer[FRM_DATA+2]);
            if(item!=ERROR)
            {                
                FrameBuffer[FRM_DATALEN]=3;
                goto Read7026;
            }
            break;
        default:
            break;
    }
    FrameBuffer[FRM_DATA] = RET_ERR_INVALID_DATA;
    return RET_SEND_ERROR_RESPONSION;
Read7026:
    SpiWriteOrder( 0xc6, 0x5A );
    Att702xRead(FrameBuffer[FRM_DATA+2],&FrameBuffer[FRM_DATA+2]);
    SpiWriteOrder( 0xc6, 0x55 );
    return(RET_SEND_RIGHT_RESPONSION);
}

static unsigned char _SlvsReadProcE9xx(void)
{
    unsigned short count;
	
    if( DI0_H == 0 )
    {
        if( DI0_L == 2 )
        {
            DI1DI0 = ADDR_OF_SOFTWARE_VERSION;
            FrameBuffer[FRM_DATALEN] = 6;
            return(RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_A);			
        }
    }		
    else if( DI0_H == 1 )
    {
        if( DI0_L == 0 )
        {
            DI1DI0 = EVT_REC_PM_CLR_BASE;
            FrameBuffer[FRM_DATALEN] = 2;
            return(RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V);
        }
        else if( DI0_L <= 0x0A )
        {
            DataflashReadByBuffer1( EVT_REC_PM_CLR_BASE, (unsigned char *)&count, 2 );
            count = Bcd2HexShort( count );
            count = count % 10;
            count = ( count+9+(DI0_L-1)*9)%10;
            DI1DI0 = EVT_REC_PM_CLR_BASE+DF_PAGE_LEN*count+2;
            FrameBuffer[FRM_DATALEN] = EVT_REC_PM_CLR_OFFSET;
            return(RET_SEND_RIGHT_RESPONSION|RET_READ_E2PROM_V); 			 
        }
    }
	
    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;    
}

static unsigned char __SlvsWriteProcC01x(void)
{	
    unsigned char ii;
	
    if( DI0_L < 2 )
    {
        for( ii = 0; ii < 3; ii++ )
        {
            if( CommPortBak & ( BIT0 << ii ) ) break;
        }        
        FramWrite( ADDR_OF_SET_TIME_BACKUP, &SystemTime[0], 7 );
        SavePastTime( ADDR_OF_METER_RUNTIME,TMPT_METER_RUN, 4);
        DI1DI0 =~ ( (unsigned short)(FrameBuffer[DI0]|0xFFFE) );
        CopySystemTime( SystemTime+(unsigned char)(3*DI1DI0), &FrameBuffer[FRM_DATA+6] );
        SetSystemTime();
        GetSystemTime();
        if( TimerCounter[TIMER_PROC_SET_TIME] == 0 )
        {
            TimerCounter[TIMER_PROC_SET_TIME] = 1;
            SaveEvtSetSysClock(ii);
        }
        SaveTmpTime(TMPT_BASE+TMPT_METER_RUN);
        return( RET_SEND_RIGHT_RESPONSION );
    }
	
    FrameBuffer[FRM_DATA] = RET_ERR_ID;	
    return RET_SEND_ERROR_RESPONSION;
}

static unsigned char __Slvs