powersupply.c

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

#include "includes.h"

unsigned short CurrentVI[6];
unsigned short CurrentFreq=0;
unsigned char VStateWord=0;
unsigned char PowerStateFlag=0;
unsigned char MeterRunningState=0;
unsigned char MeterRunningStateWord=0;
unsigned char PowerNetStateWord=0;
unsigned char LowVIStateWord=0;
unsigned char OverVIStateWord=0;
unsigned char PhaseActive=0;
unsigned char PhaseReactive=0;
unsigned char EvtLostvFlag=0;
unsigned char EvtLostvTimerCount[3]={0,0,0};
unsigned char EvtLostiFlag=0;
unsigned char EvtLostiTimerCount[3]={0,0,0};
unsigned char EvtLowvFlag=0;
unsigned char EvtOverIFlag=0;
unsigned char EvtOveriTimerCount[3]={0,0,0};
unsigned char EvtLowvTimerCount[3]={0,0,0};
unsigned char EvtLowiFlag=0;
unsigned char EvtLowiTimerCount[3]={0,0,0};
unsigned char EvtOverUpFlag=0;
unsigned char EvtOverUpTimerCount[3]={0,0,0};
unsigned char EvtOverDownFlag=0;
unsigned char EvtOverDownTimerCount[3]={0,0,0};
unsigned char EvtTimerCounter[7]={0,0,0,0,0,0,0};
unsigned char MaxTimerCounter[4][3]={{0,0,0},{0,0,0},{0,0,0},{0,0,0}};
unsigned char LimitFactorTimerCounter[2][4] = {{0,0,0,0},{0,0,0,0}};

void GetLowViStatus(unsigned char *vi)
{
    vi[0]=LowVIStateWord&0x07;
    vi[1]=(LowVIStateWord>>4)&0x07;
}

const unsigned char _dtsd_vi_status[3] = { 0x66, 0x55, 0x33 };
const unsigned short _rec_lo_page[]={EVT_OV_REC_BASE/DF_PAGE_LEN, EVT_LOST_REC_BASE/DF_PAGE_LEN, EVT_OI_REC_BASE/DF_PAGE_LEN};
const unsigned short _rec_lo_addr[]={ADDR_OF_VOLTAGE_OVER, ADDR_OF_LOST_REC, ADDR_OF_CURRENT_OVER};
const unsigned short _rec_lo_backup[]={ADDR_OF_VOLTAGE_OVER_BACKUP, ADDR_OF_LOST_BACKUP, ADDR_OF_CURRENT_OVER_BACKUP};
const unsigned short _rec_lo_len[]={EVT_OV_REC_LEN,EVT_LOST_REC_LEN,EVT_OI_REC_LEN};
const unsigned char _rec_lo_offset[]={EVT_OV_REC_OFFSET,EVT_LOST_REC_OFFSET,EVT_OI_REC_OFFSET};

void OnEvtOverLostStart(unsigned char item, unsigned char phase)
{
    unsigned short addr;
    unsigned char rec[12], i=9;	

    // 保存( 断相，过压)  总次数
    addr = _rec_lo_addr[item];
    WriteAddShortToFram(addr);

    // 保存各相( 断相，过压) 总次数
    addr = _rec_lo_addr[item]+2+phase*2;
    WriteAddShortToFram(addr);

    // 保存( 断相，失压，失流) 时刻
    addr = _rec_lo_backup[item]+phase*6;
    SaveTmpTime( addr );

    // 保存总( 断相，过压) 时刻
    if( item == 0 )
    {
        // 如果其他两相没有过压    
        if( ( ( _dtsd_vi_status[phase] & 0x0F ) & OverVIStateWord )  == 0 )
        {
            // 保存当前过压时刻        
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_OVERV_BACKUP );
        }
    }
    else if( item == 1 )
    {
        // 如果其他两相没有断相
        if( ( ( _dtsd_vi_status[phase] & 0x0F ) & MeterRunningState )  == 0 )
        {
            // 保存当前断相时刻        
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_LOST_BACKUP );
        }
    }
    else 
    {
        // 如果其他两相没有过流
        if( ( ( _dtsd_vi_status[phase] & 0xF0 ) & OverVIStateWord ) == 0 )
        {
            // 保存当前过流时刻        
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_OVERI_BACKUP );
        }
    }

    if( item == 1 )
    {
        // 断相累计总次数    
        WriteAddShortToFram( ADDR_OF_LOST_COUNT );
        // 各相断相累计总次数		
        addr = ADDR_OF_LOST_COUNT+2+phase*2;
        WriteAddShortToFram( addr ); 		
        // 最近一次断相时间		
        WriteTimeToFram( ADDR_OF_LOST_TIME, 4 );	
        WriteTimeToFram( ADDR_OF_LOST_TIME+4+phase*4, 4 );
        // 保存断相起始时间
        SaveTmpTime( ADDR_OF_LOST_LONG+12+phase*6 );
    }
	
    if( DataflashMainToBuffer1( _rec_lo_page[item] ) == OK )
    {    	
        do
        {
            DataflashBuffer1Read( _rec_lo_len[item]*phase+_rec_lo_offset[item]*(i-1), rec, _rec_lo_offset[item] );
            DataflashBuffer1Write( _rec_lo_len[item]*phase+_rec_lo_offset[item]*i, rec, _rec_lo_offset[item] );
        }while(--i);
        MemSetZero( &rec[0], _rec_lo_offset[item] );
        rec[0] = SystemTime[SPACE_OF_MINUTE];
        rec[1] = SystemTime[SPACE_OF_HOUR];
        rec[2] = SystemTime[SPACE_OF_DAY];
        rec[3] = SystemTime[SPACE_OF_MONTH];
        rec[4] = SystemTime[SPACE_OF_YEAR];
		
        if( item == 0 )
        {
            addr = Hex2BcdShort( CurrentVI[phase] );
            memcpy( (unsigned char *)&rec[10], (unsigned char *)&addr, 2 );
        }			
        else if( item == 2 )
        {
            addr = Hex2BcdShort( CurrentVI[3+phase] );
            memcpy( (unsigned char *)&rec[10], (unsigned char *)&addr, 2 );
        }
        DataflashBuffer1Write( _rec_lo_len[item]*phase, rec, _rec_lo_offset[item] );
        DataflashBuffer1ToMain( _rec_lo_page[item] );
    }			
}

void CalcTotalTime(unsigned short addr, unsigned long time_bcd)
{
    unsigned long temp=0;
	
    FramRead( addr, (unsigned char *)&temp, 3 );
    temp = __bcd_add_long(temp, time_bcd);
    FramWrite( addr, (unsigned char *)&temp, 3 );
}

void OnEvtOverLostStop(unsigned char item, unsigned char phase)
{
    unsigned long temp=0;
    unsigned short addr;
    unsigned char rec[5];	

    // 计算本次( 断相, 过压) 时间	
    addr = _rec_lo_backup[item]+phase*6;
    temp = CalcPastTime(addr);
    
    // 计算各相( 断相，过压) 时间		
    addr = _rec_lo_addr[item]+phase*3+11;
    CalcTotalTime( addr, temp );

    // 计算总( 断相, 过压) 时间
    addr = _rec_lo_addr[item]+8;   
    CalcSumLastTime( addr, item, 0 );

    if( item == 1 )
    {
        // 计算分相断相时间    
        temp = CalcPastTime( ADDR_OF_LOST_LONG+12+phase*6 );
        
        // 各相断相总时间
        addr = ADDR_OF_LOST_LONG+3+phase*3;
        CalcTotalTime( addr, temp );

        // 累计断相总时间 
        addr = ADDR_OF_LOST_LONG;
        CalcSumLastTime( addr, 1, 0 );

        // 最近一次 断相结束时间
        WriteTimeToFram( ADDR_OF_LOST_TIME+16, 4 );
        WriteTimeToFram( ADDR_OF_LOST_TIME+20+phase*4, 4 );
    }

    if( item == 0 )
    {
        // 如果其他相还有过压
        if( ( _dtsd_vi_status[phase] & 0x0F ) & OverVIStateWord )
        {
            // 保存当前时刻        
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_OVERV_BACKUP );
        }
    }
    else if( item == 1 )
    {
        // 如果其他相还有断相     
        if( ( _dtsd_vi_status[phase] & 0x0F ) & MeterRunningState )
        {
            // 保存当前时刻        
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_LOST_BACKUP );
        }
    }
    else
    {
        // 如果其他相还有过流    
        if( ( _dtsd_vi_status[phase] & 0xF0 ) & OverVIStateWord )
        {
            // 保存当前时刻        
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_OVERI_BACKUP );
        }
    }
    
    if( DataflashMainToBuffer1( _rec_lo_page[item] ) == OK )
    {
        rec[0] = SystemTime[SPACE_OF_MINUTE];
        rec[1] = SystemTime[SPACE_OF_HOUR];
        rec[2] = SystemTime[SPACE_OF_DAY];
        rec[3] = SystemTime[SPACE_OF_MONTH];
        rec[4] = SystemTime[SPACE_OF_YEAR];
        DataflashBuffer1Write( _rec_lo_len[item]*phase+5, (unsigned char *)&rec[0], 5 );
        DataflashBuffer1ToMain( _rec_lo_page[item] );
    }
}

const unsigned short _lvi_rec_page[] = { EVT_LOWV_REC_BASE/DF_PAGE_LEN, EVT_LOWI_REC_BASE/DF_PAGE_LEN };
const unsigned short _lvi_rec_addr[] = { ADDR_OF_LOWV_REC, ADDR_OF_LOWI_REC };
const unsigned short _lvi_rec_back[] = { ADDR_OF_LOWV_BACKUP, ADDR_OF_LOWI_BACKUP };
const unsigned short _lvi_rec_total_long[] ={ ADDR_OF_LOWV_TOTAL_LONG, ADDR_OF_LOWI_TOTAL_LONG };
      
void OnLviStart(unsigned char lvi, unsigned char item)
{
    unsigned long inst_demand[4];
    unsigned short addr,page,count;
    unsigned char i,j;

    // 保存本月( 失压，失流) 总次数
    addr = _lvi_rec_addr[lvi];
    WriteAddShortToFram(addr);

    // 保存总次数    
    addr = ADDR_OF_LVI_TOTAL_COUNT+lvi*6+item*2;
    count = WriteAddShortToFram( addr );

    // 保存本月各相( 失压，失流) 总次数
    addr = _lvi_rec_addr[lvi]+2+item*2;
    WriteAddShortToFram(addr);

    // 保存( 失压，失流) 时刻
    addr = _lvi_rec_back[lvi]+LVI_BACKUP_OFFSET*item+LVI_BACKUP_TIME;
    SaveTmpTime( addr );

    if( lvi == 0 )
    {
        if( ( ( _dtsd_vi_status[item] & 0x0F ) & LowVIStateWord ) == 0 )
        {
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_LOWV_BACKUP );
        }        
    }
    else
    {
        if( ( ( _dtsd_vi_status[item] & 0xF0 ) & LowVIStateWord ) == 0 )
        {
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_LOWI_BACKUP );
        }        
    }
    
    if( lvi == 0  )
    { 
        // 保存( 失压) 时的电流        
        addr = ADDR_OF_LVI_CURRENT_VI+item*2;
        FramWrite( addr, (unsigned char *)&CurrentVI[3+item], 2 );
        // 保存( 失压) 时的时间
        addr = ADDR_OF_LOWV_CURINT_BACKUP+LOWV_CURINT_BACKUP_OFFSET*item;
        SaveTmpTime( addr );		
    }
			
    // 保存( 失压，失流) 时的电量
    for( i = 0; i < 4; i++ )
    {
        if( i < 2 )
        {
            LoadEnergy( (unsigned char *)&inst_demand[0], 0xFF, i*5+5 );
        }
        else
        {
            LoadEnergy( (unsigned char *)&inst_demand[0], 0xFF, i*5+10 );
        }
        addr = _lvi_rec_back[lvi]+LVI_BACKUP_OFFSET*item+i*4;
        FramWrite( addr, (unsigned char *)&inst_demand[0], 4 );
    }

    // 保存( 失压，失流) 时ABC 三相电量
    for( i = 0; i < 3; i++ )
    {
        for( j = 0; j < 4; j++ )
        {
            LoadPhasePowerData( (unsigned char *)&inst_demand[j], 0xFF, i*4+j );
        }
        addr = _lvi_rec_back[lvi]+LVI_BACKUP_OFFSET*item+LVI_BACKUP_PA_POWER+i*16;
        FramWrite( addr, (unsigned char *)&inst_demand[0], 16 );
    }
		
    page = _lvi_rec_page[lvi]+item*2+count/5;
    if( DataflashMainToBuffer1(page) == OK )
    {    
        MemSetZero( (unsigned char *)&pub_data.pub_data_buff3[0], EVT_LVI_REC_OFFSET );	

        // 保存( 断相，失压，失流) 时间		
        pub_data.pub_data_buff3[0] = SystemTime[SPACE_OF_MINUTE];
        pub_data.pub_data_buff3[1] = SystemTime[SPACE_OF_HOUR];
        pub_data.pub_data_buff3[2] = SystemTime[SPACE_OF_DAY];			
        pub_data.pub_data_buff3[3] = SystemTime[SPACE_OF_MONTH];        
        pub_data.pub_data_buff3[4] = SystemTime[SPACE_OF_YEAR]; 
		
        // 保存( 失流) 当前需量        
        if( lvi == 1 )
        {
            CalcInstDemand( (unsigned char *)&inst_demand[0], 0 );
            memcpy( (unsigned char *)&pub_data.pub_data_buff3[EVT_LVI_CUR_REQ], (unsigned char *)&inst_demand[0], 3 );
        }			

        addr = (unsigned short)EVT_LVI_REC_OFFSET*(count%5);
        DataflashBuffer1Write( addr, (unsigned char *)&pub_data.pub_data_buff3[0], (unsigned short)EVT_LVI_REC_OFFSET );
        DataflashBuffer1ToMain(page);        
    }
}

void OnLviStop(unsigned char lvi, unsigned char item)
{
    unsigned long temp1=0,temp2=0;
    unsigned short addr,page,count;
    unsigned char i;    

    // 计算本次( 失压，失流) 时间	
    addr = _lvi_rec_back[lvi]+LVI_BACKUP_OFFSET*item+LVI_BACKUP_TIME;
    temp1 = CalcPastTime(addr);
    
    // 计算各相( 失压，失流) 时间
    addr = _lvi_rec_addr[lvi]+LVI_REC_LONG+3+item*3;
    CalcTotalTime( addr, temp1 );

    // 计算各相( 失压，失流) 总时间
    addr = _lvi_rec_total_long[lvi]+LOWV_TOTAL_LONG_OFFSET*item;
    CalcTotalTime( addr, temp1 );

    // 计算总( 失压，失流) 时间
    addr = _lvi_rec_addr[lvi]+LVI_REC_LONG;
    CalcSumLastTime( addr, lvi+3, 0 );
    
    if( lvi == 0 )
    {
        if(  ( _dtsd_vi_status[item] & 0x0F ) & LowVIStateWord )  
        {
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_LOWV_BACKUP );
        }        
    }
    else
    {
        if( ( _dtsd_vi_status[item] & 0xF0 ) & LowVIStateWord )
        {
            SaveTmpTime( ADDR_OF_SUM_LONG_BACKUP+SUM_LONG_LOWI_BACKUP );
        }        
    }
		
    addr = ADDR_OF_LVI_TOTAL_COUNT+lvi*6+item*2;
    FramRead( addr, (unsigned char *)&count, 2 );
    count = Bcd2HexShort( count );
    count = (count-1)%10;	

    // 保存恢复( 失压，失流) 时间
    pub_data.pub_data_buff3[EVT_LVI_END_TIME] = SystemTime[SPACE_OF_MINUTE];
    pub_data.pub_data_buff3[EVT_LVI_END_TIME+1] = SystemTime[SPACE_OF_HOUR];
    pub_data.pub_data_buff3[EVT_LVI_END_TIME+2] = SystemTime[SPACE_OF_DAY];
    pub_data.pub_data_buff3[EVT_LVI_END_TIME+3] = SystemTime[SPACE_OF_MONTH];
    pub_data.pub_data_buff3[EVT_LVI_END_TIME+4] = SystemTime[SPACE_OF_YEAR];

    // ( 失压，失流) 期间电能
    for( i = 0; i < 4; i++ )
    {
        if( i < 2 )
        {
            LoadEnergy( (unsigned char *)&temp1, 0xFF, i*5+5 );
        }
        else
        {
            LoadEnergy( (unsigned char *)&temp1, 0xFF, i*5+10 );
        }
        temp1 = Bcd2HexLong(temp1);
		
        addr = _lvi_rec_back[lvi]+LVI_BACKUP_OFFSET*item+LVI_BACKUP_ZAPOWER+i*4;
        FramRead( addr, (unsigned char *)&temp2, 4 );
        temp2 = Bcd2HexLong( temp2 );
		
        if( temp1 >= temp2 )
        {
            temp1 = Hex2BcdLong( temp1-temp2 );
        }
        else 
        {
            temp1 = Hex2BcdLong( temp1 );
        }
		
        memcpy( (unsigned char *)&pub_data.pub_data_buff3[EVT_LVI_APOWR_Z+i*4], (unsigned char *)&temp1, 4 );		
    }
	
    // ( 失压，失流) 期间ABC 三相电能	
    for( i = 0; i < 12; i++ )
    {
         LoadPhasePowerData( (unsigned char *)&temp1, 0xFF, i );
         temp1 = Bcd2HexLong( temp1 );
		 
         addr = _lvi_rec_back[lvi]+LVI_BACKUP_OFFSET*item+LVI_BACKUP_PA_POWER+i*4;
         FramRead( addr, (unsigned char *)&temp2, 4 );
         temp2 = Bcd2HexLong( temp2 );