powermeasure.c

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

    }
    
    if( item == 0 )
    {
        Att702xRead( ATT_ADDR_PFT, (unsigned char *)&ulTmp );
    }
    else
    {
        Att702xRead( ATT_ADDR_PFA+item-1, (unsigned char *)&ulTmp );
    }
    
    ulTmp &= 0xFFFFFF;
    if(ulTmp > 0x800000)
    {
        ulTmp = 0x1000000 - ulTmp;
    }

    ulTmp >>= 10;
    ulTmp *= 1000;    
    pcoe = (unsigned short )( ulTmp >> 13 );

    if( pcoe >= 999 )
    {
        pcoe = 1000;
    }
    pcoe = Hex2BcdShort(pcoe);
    return pcoe;
}

const unsigned char ATT_ADDR_TEMP[]={4,1,2,3,8,5,6,7,12,9,10,11};
void CalcInstantPower(unsigned char *pwr,unsigned char item)
{
    unsigned long ucPowerData;
    unsigned long instp;

    Att702xRead( ATT_ADDR_PA+ATT_ADDR_TEMP[item]-1, (unsigned char *)&ucPowerData );    
    ucPowerData &= 0xFFFFFF;
    if( ucPowerData > 0x800000 )
    {
        ucPowerData = 0x1000000-ucPowerData;
    }
	
    if( ( item % 4 ) == 0 )
    {
        ucPowerData >>= 7;
    }
    else
    {
        ucPowerData >>= 9;
    }
    instp = (unsigned long)( (ucPowerData*640)/_SysPotInfo.meter_const );
    instp = Hex2BcdLong( instp );
    memcpy( (unsigned char *)&pwr[0], (unsigned char *)&instp, 4 );
}

void CalcVoltageAngle(unsigned char *pwr,unsigned char item)
{
    unsigned long ucData,temp=0;
    float tt;	

    if( ( SystemIndication & EVT_INIT_ATT702X ) || ( item == 0 ) )
    {
        ucData = 0; 
    }	
    else
    {
        if( item < 3 )
        {
            item--;
            Att702xRead( ATT_ADDR_UANGLE_A+item, (unsigned char *)&temp );
            ucData = (temp*100) >>13;
            ucData = Hex2BcdLong(ucData);
        }
        else if( item < 6 )
        {
            Att702xRead( ATT_ADDR_PGA+item-3, (unsigned char *)&temp );
            Delay(250);
            if( temp > 0x800000 )
            {
                temp = 0x1000000-temp;
            }
            tt = (temp*180)>>22;
            tt *= 100;
            tt /= 3.14;	
            ucData = (ulong)tt;
            if( !( PhaseActive & ( BIT0 << ( item-3 ) ) ) )
            {
                if( PhaseReactive & ( BIT0 << ( item-3 ) ) )
                {
                    ucData = 36000 - ucData;
                }
            }
            else
            {
                if( !( PhaseReactive & ( BIT0 << ( item-3 ) ) ) )
                {
                    ucData = 18000-ucData;
                }
                else
                {
                    ucData += 18000;
                }
            }
            ucData = Hex2BcdLong( ucData );			
        }
    }		
    memcpy( (unsigned char *)&pwr[0], (unsigned char *)&ucData, 3 );
}

void SaveReqOverload(void)
{
    unsigned long max_req,temp=0;

    max_req = 0;
    FramRead( ADDR_OF_REQ_OV_UPVAL, (unsigned char *)&max_req, 3 );
    max_req = Bcd2HexLong( max_req );

    CalcInstDemand( (unsigned char *)&temp, 0 );
    temp = Bcd2HexLong( temp );
    if( temp > max_req )
    {
        if( !( EvtTimerCounterflag & BIT2 ) )
        {
            EvtTimerCounterflag |= BIT2;
            EvtTimerCounter[2] = 0;            			
        }

        if( !( AlarmCtlWord2 & ALARM_OF_OV_REQ ) )
        {
            if( EvtTimerCounter[2]++ >= _SysPotInfo.timer_count[EVT_TC_REQOVER] )
            {
                EvtTimerCounter[2] = 0;        
                AlarmCtlWord2 |= ALARM_OF_OV_REQ;
                SaveEvtStartInfo(3);
            }				
        }		    
    }
    else
    {
        if( EvtTimerCounterflag & BIT2 )
        {
            EvtTimerCounterflag &=~ BIT2;
            EvtTimerCounter[2] = 0;
        }
    
        if( AlarmCtlWord2 & ALARM_OF_OV_REQ )
        {
            if( EvtTimerCounter[2]++ >= _SysPotInfo.timer_count[EVT_TC_REQOVER] )
            {
                EvtTimerCounter[2] = 0;                
                AlarmCtlWord2 &=~ ALARM_OF_OV_REQ;
                SaveEvtStopInfo(3);
            }				
        }
    }	    	
}

void SaveWattOverload(void)
{    
    unsigned long max_watt,temp[3];
    unsigned char i;
	
    max_watt = 0;
    FramRead( ADDR_OF_WATT_OV_UPVAL, (unsigned char *)&max_watt, 3 );
    max_watt = Bcd2HexLong(max_watt);
    max_watt *= 100;	

    for( i = 0; i < 3; i++ )
    {
        temp[i] = (unsigned long)CurrentVI[i]*CurrentVI[3+i];
    }

    temp[0] += ( temp[1]+temp[2] );
    if( temp[0] > max_watt )
    {
        if( !( EvtTimerCounterflag & BIT3 ) )
        {
            EvtTimerCounterflag |= BIT3;
            EvtTimerCounter[3] = 0;
        }
		
        if( !( AlarmCtlWord2 & ALARM_OF_OV_LOAD ) )
        {
            if( EvtTimerCounter[3]++ >= _SysPotInfo.timer_count[EVT_TC_WATTOVER] )
            {
                EvtTimerCounter[3] = 0;
                AlarmCtlWord2|=ALARM_OF_OV_LOAD;
                SaveEvtStartInfo(2);
            }				
        }		    
    }
    else
    {
        if(  EvtTimerCounterflag & BIT3 )
        {
            EvtTimerCounterflag &=~ BIT3;
            EvtTimerCounter[3] = 0;            			
        }
    
        if( AlarmCtlWord2 & ALARM_OF_OV_LOAD )
        {
            if( EvtTimerCounter[3]++ >= _SysPotInfo.timer_count[EVT_TC_WATTOVER] )
            {
                EvtTimerCounter[3] = 0;
                AlarmCtlWord2&=~ALARM_OF_OV_LOAD;
                SaveEvtStopInfo(2);
            }				
        }
    }	
}

void SaveWattReverse(void)
{
    if( PhaseActive & BIT4 )
    {
        if( !( EvtTimerCounterflag & BIT6 ) )
        {
            EvtTimerCounterflag |= BIT6;
            EvtTimerCounter[6] = 0;
        }

        if( !( AlarmCtlWord3 & ALARM_OF_WATT_RESERVE ) )
        {
            if( EvtTimerCounter[6]++ >= 5 )
            {
                EvtTimerCounter[6] = 0;
                AlarmCtlWord3 |= ALARM_OF_WATT_RESERVE;
                SaveEvtStartInfo(5);
            }	        
        }
    }
    else
    {
        if(  EvtTimerCounterflag & BIT6 )
        {
            EvtTimerCounterflag &=~ BIT6;
            EvtTimerCounter[6] = 0;            			
        }
    
        if( AlarmCtlWord3 & ALARM_OF_WATT_RESERVE )
        {
            if( EvtTimerCounter[6]++ >= 5 )
            {
                EvtTimerCounter[6] = 0;
                AlarmCtlWord3 &=~ ALARM_OF_WATT_RESERVE;
                SaveEvtStopInfo(5);
            }
        }    
    }
}

void SaveManualReadData(void)
{
    unsigned short temp1,temp2;
    unsigned char i,j = 4;
    
    PowerDataStoreRuleDay();            
    ClearTodayData();
    SaveCurrMd2Flash();
    do
    {        		
        temp1 = (ushort)(GetPrevMonAddr(j-1)/DF_PAGE_LEN);	
        temp2 = (ushort)(GetPrevMonAddr(j)/DF_PAGE_LEN);    
        for( i = 0; i < 2; i++ )
        {	    
            if( DataflashMainToBuffer1(temp1+i) == OK )
            {
                DataflashBuffer1ToMain(temp2+i);
            }		
        }    
    }	while( --j > 1 );
    PowerDataShift(Bcd2HexChar(SystemTime[SPACE_OF_YEAR]),SystemTime_MonthHex);        
    ClearCurrentMonthData(BASE_CUR);
    ClearMinPwrPreReqCycle();		
    PowerMeterClrReqData();	
}

const unsigned char _calc_factor_item[4] ={ 1, 2, 3, 0 };
void CalcDayDataInfo(void)
{
    unsigned long temp,factor;
    unsigned short averagePtr,tt;
    unsigned char ii;	

    FramRead( ADDR_OF_DAY_AVERAGE_PTR, (unsigned char *)&averagePtr, 2 );
    averagePtr++;
    FramWrite( ADDR_OF_DAY_AVERAGE_PTR, (unsigned char *)&averagePtr, 2 );

    for( ii = 0; ii < 6; ii++ )
    {
        FramRead( ADDR_OF_DAY_AVERAGE_INFO+ii*4, (unsigned char *)&temp, 4 );
        temp += (unsigned long)CurrentVI[ii]*10;
        FramWrite( ADDR_OF_DAY_AVERAGE_INFO+ii*4, (unsigned char *)&temp, 4 );

        temp /= averagePtr;
        temp = Hex2BcdLong( temp );
        FramWrite( ADDR_OF_DAY_DATA_START+DAY_PHVA_INFO+DAY_PH_OFFSET*ii+DAY_AVERAGE_VAL, (unsigned char *)&temp, 3 );
    }
    
    for( ii = 0; ii < 4; ii++ )
    {
        FramRead( ADDR_OF_DAY_AVERAGE_INFO+DAY_AVERAGE_PHFA_INFO+ii*4, (unsigned char *)&temp, 4 );
        tt = GetPowerFactor( _calc_factor_item[ii] );
        tt = Bcd2HexShort( tt );
        factor = (ulong)tt*10;
        temp += factor;
        FramWrite( ADDR_OF_DAY_AVERAGE_INFO+DAY_AVERAGE_PHFA_INFO+ii*4, (unsigned char *)&temp, 4 );

        temp /= averagePtr;
        temp = Hex2BcdLong( temp );
        FramWrite( ADDR_OF_DAY_DATA_START+DAY_PHFA_INFO+DAY_PH_OFFSET*ii+DAY_AVERAGE_VAL, (unsigned char *)&temp, 3 );
    }    
}

void CalcMonAverInfo(void)
{
    unsigned long temp1= 0, temp2 = 0;
    unsigned short averagePtr;
    unsigned char ii;

    FramRead( ADDR_OF_MON_AVERAGE_PTR, (unsigned char *)&averagePtr, 2 );
    averagePtr++;
    FramWrite( ADDR_OF_MON_AVERAGE_PTR, (unsigned char *)&averagePtr, 2 );

    for( ii = 0; ii < 10; ii++ )
    {
        FramRead( ADDR_OF_DAY_DATA_START+DAY_PHVA_INFO+DAY_PH_OFFSET*ii+DAY_AVERAGE_VAL, (unsigned char *)&temp1, 3 );
        temp1 = Bcd2HexLong( temp1 );
        FramRead( ADDR_OF_MON_AVERAGE_INFO+ii*4, (unsigned char *)&temp2, 4 );
        temp2 += temp1;
        FramWrite( ADDR_OF_MON_AVERAGE_INFO+ii*4, (unsigned char *)&temp2, 4 );

        temp2 /= averagePtr;
        temp2 = Hex2BcdLong( temp2 );		
        FramWrite( ADDR_OF_MON_DATA_START + MON_PH_OFFSET * ii + MON_AVERAGE_VAL, (unsigned char *)&temp2, 3 );
    }
}

void CalcMonMaxInfo(void)
{
    unsigned long temp1=0, temp2 = 0;
    unsigned short addr1,addr2;
    unsigned char ii,temp[4];

    for( ii = 0; ii < 10; ii++ )
    {
        // 读出每天最大值    
        addr1 = ADDR_OF_DAY_DATA_START + DAY_PHVA_INFO + DAY_PH_OFFSET*ii + DAY_MAX_VAL;
        FramRead( addr1, (unsigned char *)&temp1, 3 );

        // 读出每月最大值
        addr2 = ADDR_OF_MON_DATA_START + MON_PHVA_INFO + MON_PH_OFFSET*ii + MON_MAX_VAL;
        FramRead( addr2, (unsigned char *)&temp2, 3 );
        if( temp1 > temp2 )
        {
            // 保存最大值
            FramWrite( addr2, (unsigned char *)&temp1, 3 );
            // 保存最大值发生的时间
            FramRead( addr1 + DAY_MAX_TIME, (unsigned char *)&temp[0], 4 );
            FramWrite( addr2 + MON_MAX_TIME, (unsigned char *)&temp[0], 4 );
        }

        // 读出每日最小值
        FramRead( addr1 + DAY_MIN_VAL, (unsigned char *)&temp1, 3 );
        // 读出每月最小值
        FramRead( addr2 + MON_MIN_VAL, (unsigned char *)&temp2, 3 );
        if( ( temp1 < temp2 ) || ( temp2 == 0 ) )
        {
            FramWrite( addr2 + MON_MIN_VAL, (unsigned char *)&temp1, 3 );
            FramRead( addr1 + DAY_MIN_TIME, (unsigned char *)&temp[0], 4 );
            FramWrite( addr2 + MON_MIN_TIME, (unsigned char *)&temp[0], 4 );
        }
    }
}