voltage.c

应用与电网中电压合格率的统计。经过现场的投运使用

/******************************************************
  Copyright(C)    2007-2008,      Huaruijie Co.Ltd.
  File name :     Voltage.C
  Author :        ZHW
  Version:        1.0
  Date:           2007.02.25   
  Description:    电压合格率数据处理 负荷处理  事件记录 变压器运行统计功能
  Other:
  Function List:
  History:
	  <author>   <time>     <version>   <desc>
		ZHW      07/02/25     1.0       Create  and use some functions of 801


2007-02-25  增加对AD采样芯片的初始化，如果多(20)次出现如下情况
			1、多次读取的值相同
			2、值小于2V
			3、值大于600V
******************************************************/
//#include "includes.h"
#include "basetype.h"
#include "DrvCfg.h"
#include "cs5463.h"
#include "HRJ803.h"
#include "driver.h"
#include "db.h"
#include "fat.h"
#include "UartDrv.h"
#include "Pulse.h"
#include "lcm.h"
#define MAX_LU_NUM   3 //最大路数，在目前硬件条件下无需改动,即使仅安装一块CS5463，也不必改动
#define MAX_SHOW_LU_NUM 3 //一般来说，安装几块5463，此值就是几

#define EXCEED_RATIO     0.25
#define THRESHOLD_RATIO  0.07
#define K_ERROR_RATIO    0.2

#define OVER_VOLTAGE        0x90
#define EXCEED_UP_STATIC	0x80  //
#define EXCEED_UP_LIMIT		0x70
#define VOLTAGE_REGULAR		0x60
#define EXCEED_DOWN_LIMIT	0x50
#define EXCEED_DOWN_STATIC	0x40
#define LOSE_VOLTAGE        0x40
#define NO_STAT				0x0
#define STOP_STAT			0x10
#define NORMAL_STAT			0x20


BOOL MUST_LOAD_THRESHOLD ;
BYTE byErrFlay[MAX_LU_NUM];
BOOL MUST_INITIAL_5460;


typedef struct
{
	DWORD dwStateNum_d;//用在天统计，一分钟内的有效值采样次数，正常为60次
	DWORD dwStateNum_m;//用在月统计，一分钟内的有效值采样次数，正常为60次
	DWORD dwStateValue_d; ////用在天统计，一分钟内的有效值的累加和，正常为60次
	DWORD dwStateValue_m; //用在月统计，一分钟内的有效值的累加和，正常为60次	
}STAT_TIME;

typedef struct
{
	SDateTime sLastSamTime ;
	SDateTime sMonthLastTime;
	BYTE   flag[MAX_LU_NUM] ;  //重新初始化AD的标志

	DWORD Un[MAX_LU_NUM];
	DWORD Uup[MAX_LU_NUM];
	DWORD Udown[MAX_LU_NUM];
	DWORD Uup2[MAX_LU_NUM];
	DWORD Udown2[MAX_LU_NUM];
	DWORD U_Error[MAX_LU_NUM];
    DWORD UOver[MAX_LU_NUM];
	DWORD ULose[MAX_LU_NUM];
	DWORD Utemp[MAX_LU_NUM];  //?

	BYTE  Exceed_FLAG[MAX_LU_NUM] ;
    BYTE  OverLose_Flag[MAX_LU_NUM]; //过压、欠压、或正常

	BYTE lastSecond ;//最近一次的秒数

	STAT_TIME stat_time[MAX_LU_NUM]; //统计时间量
    DWORD dwDcValue_d; //用在天统计，一分钟内的有效值的累加和，正常为60次
	DWORD dwDcValue_m; //用在月统计，一分钟内的有效值的累加和，正常为60次

	BYTE RUN_STAT_FLAG[MAX_LU_NUM]; //是否在统计标志0未启动，1停止，2正常采样
}RAM_DATA;


WORD wVOLTAGE_STANDARD[MAX_LU_NUM];
WORD wVOLTAGE_BANK[MAX_LU_NUM] ;
RAM_DATA ram_Data ;

void InitV_Standard(void)
{
	BYTE i ;
	WORD wVoltStandard;
   	LoadParam((DWORD)&p_gcSysParam->sMeterParam.wUn, (BYTE*)&wVoltStandard, sizeof(WORD)); 

	for (i=0; i<MAX_LU_NUM; i++)
	{
		//LoadFram(byVoltStandard[i], &byVoltStandard[i]);
		/*if (g_sVoltageCompute.byVoltStandard[i] == 0x31)
		{
			wVOLTAGE_STANDARD[i] = 100 ;
			wVOLTAGE_BANK[i] = 125 ;
		}
		else if (g_sVoltageCompute.byVoltStandard[i] == 0x32)
		{
			wVOLTAGE_STANDARD[i] = 220 ;
			wVOLTAGE_BANK[i] = 275 ;
		}
		else if (g_sVoltageCompute.byVoltStandard[i] == 0x33)
		{
			wVOLTAGE_STANDARD[i] = 380 ;
			wVOLTAGE_BANK[i] = 475 ;
		}
		else 
		{
			g_sVoltageCompute.byVoltStandard[i] = 0x32 ;
			wVOLTAGE_STANDARD[i] = 220 ;
			wVOLTAGE_BANK[i] = 275 ;
		}
		*/
		wVOLTAGE_STANDARD[i] = wVoltStandard /10;
	}
}
//整定值与上下限值数据从配置文件中读取
void LoadThreshold(SRestrict *psRestrict)
{
	BYTE i;
	BOOL bValid;
	BYTE byType;
	BYTE byProtocol;
	BYTE find =10;
	MUST_LOAD_THRESHOLD = FALSE;
	InitV_Standard();
	for(i=0; i<MAX_SHOW_LU_NUM; i++)
	{
  	  ram_Data.Uup[i] = psRestrict->wUperVoltLevel ;
      ram_Data.Udown[i] = psRestrict->wLowerVoltLevel;
      ram_Data.Un[i] = wVOLTAGE_STANDARD[i]*10;
	  ram_Data.UOver[i] = psRestrict->wOverVoltLevel;
	  ram_Data.ULose[i] = psRestrict->wLoseVoltLevel ;
    }
	/*else
	{
		ram_Data.Un[0] = wVOLTAGE_STANDARD[0]*100;
		ram_Data.Uup[0] = (int)((float)ram_Data.Un[0]*(1+THRESHOLD_RATIO));
		ram_Data.Udown[0] = (int)((float)ram_Data.Un[0]*(1-THRESHOLD_RATIO));
		if (MAX_SHOW_LU_NUM>1)
		{
			ram_Data.Un[1] = wVOLTAGE_STANDARD[1]*100;
			ram_Data.Uup[1] = (int)((float)ram_Data.Un[1]*(1+THRESHOLD_RATIO));
			ram_Data.Udown[1] = (int)((float)ram_Data.Un[1]*(1-THRESHOLD_RATIO));
		}
		if (MAX_SHOW_LU_NUM>2)
		{
			ram_Data.Un[2] = wVOLTAGE_STANDARD[2]*100;
			ram_Data.Uup[2] = (int)((float)ram_Data.Un[2]*(1+THRESHOLD_RATIO));
			ram_Data.Udown[2] = (int)((float)ram_Data.Un[2]*(1-THRESHOLD_RATIO));
		}
	}
	*/
}
//初始化数据区
void InitData(SRestrict *psRestrict)
{
	BYTE i;
	memset(&ram_Data, 0, sizeof(RAM_DATA));

	byErrFlay[0] = 0;
	byErrFlay[1] = 0;
	byErrFlay[2] = 0;

	LoadThreshold(psRestrict);
	for (i=0;  i<MAX_SHOW_LU_NUM;  i++)
	{
		GetTime(&(ram_Data.sLastSamTime));
		GetTime(&ram_Data.sMonthLastTime);
		ram_Data.lastSecond = ram_Data.sLastSamTime.bySecond;
		ram_Data.U_Error[i] = (ram_Data.Un[i]*K_ERROR_RATIO/100.0);
		ram_Data.Uup2[i] = psRestrict->wOverVoltLevel;  //mod zhw 2007-3-13
		ram_Data.Udown2[i] = psRestrict->wLoseVoltLevel;//mod zhw 2007-3-13
		ram_Data.Exceed_FLAG[i] = EXCEED_DOWN_STATIC;
		ram_Data.OverLose_Flag[i] = EXCEED_DOWN_STATIC;//LOSE_VOLTAGE; //初始的欠压
		ram_Data.RUN_STAT_FLAG[i] = NO_STAT;
 		ram_Data.stat_time[i].dwStateNum_d = 0;
 		ram_Data.stat_time[i].dwStateNum_m = 0;
	}
}
//重新初始化数据区，包括了额定值更改后相应变化
void ReInitData(SRestrict *psRestrict)
{
	int i;
	DWORD UnTemp[MAX_LU_NUM];
	DWORD i16Temp;
	DWORD i32Temp;
	InitData(psRestrict);
	for (i=0;  i<MAX_SHOW_LU_NUM;  i++)
	{
		/*UnTemp[i] = ram_Data.Un[i];  //?
		i32Temp =  g_sVoltStat.dwMaxU[i];
		i32Temp = ((float)i32Temp/(float)UnTemp[i]*(float)ram_Data.Un[i]);
        g_sVoltStat.dwMaxU[i] = i16Temp;

        i32Temp =  g_sVoltStat.dwMinU[i];
		i32Temp = ((float)i32Temp/(float)UnTemp[i]*(float)ram_Data.Un[i]);
        g_sVoltStat.dwMinU[i] = i16Temp;
        i32Temp = 0;
        i32Temp =  g_sVoltageCompute.dwU[i];
		
		i32Temp = ((float)i32Temp/(float)UnTemp[i]*(float)ram_Data.Un[i]);
		g_sVoltageCompute.dwU[i] = i32Temp;
        */
		/*i16Temp = 0;
		LoadFram(monData[i].maxVal, &i16Temp);
		i16Temp = ((float)i16Temp/(float)UnTemp[i]*(float)ram_Data.Un[i]);
		SaveFram(monData[i].maxVal, &i16Temp);

		i16Temp = 0;
		LoadFram(monData[i].minVal, &i16Temp);
		i16Temp = ((float)i16Temp/(float)UnTemp[i]*(float)ram_Data.Un[i]);
		SaveFram(monData[i].minVal, &i16Temp);
     	i32Temp = 0;
		LoadFram(monData[i].total, &i32Temp);
		i32Temp = ((float)i32Temp/(float)UnTemp[i]*(float)ram_Data.Un[i]);
		SaveFram(monData[i].total, &i32Temp);
         */
	}
}
//检查相应标志是否置位，如果没有格式化储存器
BOOL CheckParamFlag(void)
{
    BYTE i;
	DWORD *pValue;
	DWORD dwTemp;
	if( g_sVoltageCompute.ParamFlag[0] == 0x55 
	    && 
	    g_sVoltageCompute.ParamFlag[1] == 0xaa) 
	{
	  // Print("9999999");
	/*  dwTemp = g_sVoltageCompute.dwTimeCnt[0] ++;
	   WriteCom(0,(BYTE*)&dwTemp,4);
	  dwTemp = g_sEneryCnt.dwEPap;
	   WriteCom(0,(BYTE*)&dwTemp,4); 
	   dwTemp = g_sEneryCnt.dwEPap ++;
       WriteCom(0,(BYTE*)&dwTemp,4);
	   dwTemp = g_dwEnergyCntRatio;
	    WriteCom(0,(BYTE*)&dwTemp,4);
	  
	   dwTemp = g_sTransFormerState.dwEPpMaxDemand++;
	     WriteCom(0,(BYTE*)&dwTemp,4);
	      Print("9999999");
	      */
	  return TRUE;
	 }
	else
	{
	    // Print("000000");
		/*清除*/
		pValue = (DWORD*)&g_sEneryCnt;
	   for(i=0; i<sizeof(SEnergyCnt)/sizeof(DWORD); i++)
	   {
		   *pValue = 0;
		    pValue ++;
	   }
	   pValue = (DWORD*)&g_sEnergy;
	   for(i=0; i<sizeof(SEnergy)/sizeof(DWORD); i++)
	   {
		   *pValue = 0;
		    pValue ++;
	   }
		pValue = (DWORD*)&g_sMaxDemand;
	   for(i=0; i<sizeof(SMaxDemand)/sizeof(DWORD); i++)
	   {
		   *pValue = 0;
		    pValue ++;
	   }
	   
	    pValue = (DWORD*)&g_sTransFormerState;
        for(i=0; i<sizeof(STransFormerState)/sizeof(DWORD); i++)
	    {
		   *pValue = 0;
		    pValue ++;
	    }
	   pValue = (DWORD*)&g_sVoltStat;
        for(i=0; i<sizeof(SVoltStat)/sizeof(DWORD); i++)
	    {
		   *pValue = 0;
		    pValue ++;
	    }
		pValue = (DWORD*)&g_sVoltageCompute;
        for(i=0; i<sizeof(SVoltageCompute)/sizeof(DWORD); i++)
	    {
		   *pValue = 0;
		    pValue ++;
	    }
		
	    pValue = (DWORD*)&g_sBreakVoltState;
        for(i=0; i<sizeof(SBreakVoltState)/sizeof(DWORD); i++)
	    {
		   *pValue = 0;
		    pValue ++;
	    }
		 pValue = (DWORD*)&g_sMeterState;
        for(i=0; i<sizeof(SMeterState)/sizeof(DWORD); i++)
	    {
		   *pValue = 0;
		    pValue ++;
	    }	
		g_sVoltageCompute.ParamFlag[0] = 0x55;
		g_sVoltageCompute.ParamFlag[1] = 0xaa;
        g_dwEC1 = 0;
        g_dwEC2 = 0;
		g_dwErcStatus[0] = g_dwErcStatus[1] = 0;
		g_dwEventPos = 0;
		for(i=0; i<MAX_TASK_COM; i++)
		{
		
		  g_sEventSendEc1[i].wNum = 0;
		  g_sEventSendEc1[i].wReadySendRecPos = 0;
	      g_sEventSendEc2[i].wNum = 0;
	  	  g_sEventSendEc2[i].wReadySendRecPos = 0;   
		}
	   return FALSE;
	}
}

//
void InitState(SRestrict *psRestrict)
{
	ReInitData(psRestrict);
}

//保存天数据
void SaveDayData(SVoltStat *psVoltStat, SDateTime*pLastTime,SDateTime*pCurTime)//从NVRAM中读取天数据并保存
{
	DWORD  i;
	DWORD *ptrS;
	DWORD *ptrD;
    SVoltStatRec sVoltStatRec;
	STime4 sTime4;	
    sVoltStatRec.sTime.byMinute = pCurTime->byMinute;
    sVoltStatRec.sTime.byHour = pCurTime->byHour;
    sVoltStatRec.sTime.byDay = pCurTime->byDay;
    sVoltStatRec.sTime.byMonth = pCurTime->byMonth;
    sTime4.byMinute = pLastTime->byMinute;
    sTime4.byHour = pLastTime->byHour;
    sTime4.byDay = pLastTime->byDay;
    sTime4.byMonth = pLastTime->byMonth;

    ptrS = (DWORD*)psVoltStat;
    ptrD = (DWORD*)&sVoltStatRec.sStat;
    for(i=0; i<sizeof(SVoltStat)/sizeof(DWORD); i++,ptrS++,ptrD++)
       *ptrD = *ptrS;
    SaveVoltStatRec(&sTime4,&sVoltStatRec);//保存电压合格率统计数据

    ptrD = (DWORD*)psVoltStat;
    for(i=0; i<sizeof(SVoltStat)/sizeof(DWORD); i++,ptrD++)
       *ptrD =0;
}

//保存月数据
BYTE byVoltageSaveMonth;
void SaveMonthData(SVoltStat *psVoltStat, BYTE byMonth)//从NVRAM中读取天数据并保存
{
	DWORD  i;
	STime4 sTime4;	
	DWORD *ptrD;
    sTime4.byMonth = byMonth;
    SaveVoltStatRec_m(&sTime4, psVoltStat);//保存月电压合格率统计数据
    ptrD = (DWORD*)psVoltStat;
    for(i=0; i<sizeof(SVoltStat)/sizeof(DWORD); i++,ptrD++)
       *ptrD = 0;
}

//保存分钟数据
void SaveMinData(BYTE byIndex, WORD temp, SDateTime*pTime)