9311fdr.c

详细介绍了arm7-at91r40008,的开发全过程

/*------------------------------------------------------------------*/
/*模块名称：9311fdr.c                                            	*/
/*模块功能：电压型馈线故障检测	                           			*/
/*编写日期：2005年9月                                         		*/
/*编写者：  dingding												*/
/*------------------------------------------------------------------*/


#include "includes.h"
#include "9311fdr.h"



//全局变量
extern INT8U			TGSH;
extern BOOL				ACTING;
extern SOEtmp_t			*SOEtmp;
extern struct MyConfig	MyCfg;
extern struct SysConfig	SysCfg;
extern struct YCPara_t	YCPara;
extern INT16U			YKOnCounter;

extern OS_EVENT		*SemFA;
extern OS_EVENT		*SemFAOneS;

extern struct YCTempData	YCTemp[MAXYCFD];
extern INT16U		FDNum, FDOTHERYXNUM;
extern INT32U		*TempYc;
extern INT16U		TestCounter, ReCounter;
extern struct YKDelayMem	YKMem;
struct FdrFeeder_t 		*Fd;
struct FdrRunInfo_t		*FdrInfo;

//变量定义
#ifdef CHINESEINFO

char *FDRInfo[] = \
{"正常...", "失去电压...", "进入X时限...", "进入Y时限...", "闭锁..."};

char *FDRSwDo[] = \
{"重合", "跳开", "闭锁", "解锁"};

#else

char *FDRInfo[] = \
{"Normal...", "Qualify NoU...", "X-Time...", "Y-Time...", "Lock Out..."};

char *FDRSwDo[] = \
{"Reclose", "Trip", "Lock", "Unlock"};

#endif


/*------------------------------------------------------------------*/
/*函数名称：FDRTask()												*/
/*函数功能：电压型故障检测任务										*/
/*------------------------------------------------------------------*/
void FdrTask(struct SysPort *Info)
{
	BOOL	rc = FALSE;
	INT8U	i, err;
	INT16U	events;
	
	rc = FdrInit();
	if (!rc)
	{
		#ifdef CHINESEINFO
			ErrorInfo(FAID, "初始化故障检测任务失败...");
		#else
			ErrorInfo(FAID, "FA Task init failed");
		#endif		
		OSTaskDel(FAID);
	}
		
	while (1)
	{
		events = OSFlagPend(Info->Event, TIME100MS+FCOS+FYCRDY,
			OS_FLAG_WAIT_SET_ANY+OS_FLAG_CONSUME, 0, &err);	
		
		if (events & FCOS)
		{
			FdrRenewYx();
			FdrDetectYX();
		}
		
		if (events & FYCRDY)
		{
			
			FdrReadYc();
			FdrDetect();
			
			//延时遥控
			if (YKMem.Flag)
			{
				FdrSwitchDo(YKMem.No, YKMem.ON_OFF);
			}
		}
		
		if (events & TIME100MS)
		{
			//复位故障信息
			for (i=0; i<FDNum; i++)		
			{
				if (!(Fd[i].Flag & FDRENABLE))
					continue;
					
				if (FdrInfo[i].FaultInfo.ResetCounter)
				{
					FdrInfo[i].FaultInfo.ResetCounter--;
					if (FdrInfo[i].FaultInfo.ResetCounter == 0)
						FDRResetInfo(i+1);
				}
			}
		}
	}
}

/*------------------------------------------------------------------*/
/*函数名称：FdrInit()												*/
/*函数功能：任务参数初始化											*/
/*------------------------------------------------------------------*/
BOOL FdrInit(void)
{
	INT8U	i, j, tmp, yxval;
	INT32U	tt;
//	INT8U	yxval[FASOFTBINUM];
	struct DBInfo	info;
		
	//申请内存
	Fd = malloc (FDNum * sizeof(struct FdrFeeder_t));
	FdrInfo = malloc (FDNum *  sizeof(struct FdrRunInfo_t));	
	TempYc = malloc (FDNum *  sizeof(INT32U) * FDRYCNUM);
	if (!(FdrInfo && Fd && TempYc))
	{
		return (FALSE);
	}
	else
	{
		memset ((INT8U*)Fd, 0, (FDNum * sizeof(struct FdrFeeder_t)));
		memset ((INT8U*)FdrInfo, 0 , (FDNum * sizeof(struct FdrRunInfo_t)));
		memset ((INT8U*)TempYc, 0 , (FDNum * sizeof(INT32U) * FDRYCNUM));
	}
	
	//初始化参数
	for (i=0; i<FDNum; i++)
	{
		Fd[i].Flag = MyCfg.Fd[i].FdrFlag;
		if (MyCfg.Fd[i].Control & FDR_ENABLE)
			Fd[i].Flag |= FDRENABLE;
		else
			continue;
		
		tmp = (MyCfg.Fd[i].FdrTime & FDRMODEBITS) >> 6;
		switch (tmp)
		{
			case 0:
				Fd[i].Mode = FDRMODE1;
				break;
			
			case 1:
				Fd[i].Mode = FDRMODE2;
				break;
				
			case 2:
				Fd[i].Mode = FDRMODE3;
				break;
				
			case 3:
				Fd[i].Mode = FDRMODE4;
				break;
				
			default:
				return (FALSE);
		}
		
		Fd[i].Mode = Fd[i].Mode * 100 / FDRCRC;  
		Fd[i].XTime = Fd[i].Mode * (MyCfg.Fd[i].FdrTime & FDRTIMEBITS);
		if (Fd[i].XTime == 0)
			return (FALSE);
		Fd[i].YTime = YTIME / FDRCRC;
		Fd[i].ZTime = ZTIME / FDRCRC;
		Fd[i].ITime = ITIME / FDRCRC;
		
		
		Fd[i].SwYXNo = DEFBINUM * i + 0;
		Fd[i].SwYKNo = DEFYKNUM * i + SWYKNO;
		Fd[i].SwLocNo = DEFBINUM * i + SWLOCNO;
		Fd[i].YKLocNo = DEFYKNUM * i + SWLOCNO;
		
		//Fd[i].HZFAILTime = HZFAILTIME / FDRCRC;
		Fd[i].HZFAILTime = (MyCfg.Bo[Fd[i].SwYKNo-1].OnTime + 10) / FDRCRC;
		
		//参数没有整定
		if (!SysCfg.ParaValid)
		{
			for (j=0; j<FDNum; j++)
				Fd[j].Flag &= ~FDRENABLE;
			
			#ifdef CHINESEINFO
				ErrorInfo(FAID, "遥测没有整定，故障检测失效");	
			#else
				ErrorInfo(FAID, "Yc para invalid, FA disable");
			#endif
			
			return (FALSE);
		}	
		
		tt = (YCPara.Value[i*10+0] * MyCfg.Ai[i*13+0].Xs2) / (MyCfg.Ai[i*13+0].Xs1);	//Uab
		tt = (tt * LOWULIMIT) / 2200;
		Fd[i].LowULimit = MyPow(tt, 2);
	}
	
	//运行状态初始化
	if (!FdrInitRunInfo())
		return (FALSE);
		
	//初始化输出的故障遥信
	for (i=0; i<FDNum; i++)
	{
		
		info.DevID = ROOTID;
		info.Type = YXDATA;
		
		if (Fd[i].Flag & FDRENABLE)
		{
			yxval = YX_H;
			info.Start = FDOTHERYXNUM + FASOFTBINUM * i;
			info.Num = 1;
			DBWrite(&yxval, &info);
		}
		
		if (FdrInfo[i].FlagLoc)
		{
			yxval = YX_H;
			info.Start = FDOTHERYXNUM + FASOFTBINUM * i + 1;
			info.Num = 1;
			DBWrite(&yxval, &info);
		}		
	}	
	
	return (TRUE);
}

/*------------------------------------------------------------------*/
/*函数名称：FdrInitRunInfo()										*/
/*函数功能：任务参数初始化子函数，运行状态初始化					*/
/*------------------------------------------------------------------*/
BOOL FdrInitRunInfo(void)
{
	BOOL	rc;
	INT8U	i, j;
	struct DBInfo	info;
	
	//读取遥信值
	rc = FdrRenewYx();
	if (!rc)
		return (FALSE);

	for (i=0; i<FDNum; i++)
	{
		if (!(Fd[i].Flag & FDRENABLE))
			continue;
		
		for (j=0; j<5; j++)
			FdrInfo[i].Timer[j] = 0;
		
		FdrInfo[i].State = 0xFF;
		FdrInfo[i].PreState = 0xF0;
				
		if (FdrInfo[i].SwLocVal == YX_H)
		{
			info.DevID = ROOTID;
			info.Type = FDRLOC;
			info.Num = i;
			DBRead(&j, &info);
			
			if (j == RESET_CLR)
				FdrInfo[i].FlagLoc = FALSE;
			else
				FdrInfo[i].FlagLoc = TRUE;
			
			FDRStateChange(i+1, RS_LOC);
		}
		else
		{
			FDRStateChange(i+1, RS_NORMAL);
		}
		
		FdrInfo[i].PreState = FdrInfo[i].State;
	}	
	
	return (TRUE);
}

/*------------------------------------------------------------------*/
/*函数名称：FdrDetect()												*/
/*函数功能：故障检测，主函数完成对数据的判断，进行状态转换			*/
/*------------------------------------------------------------------*/
void FdrDetect(void)
{
	BOOL	rc;
	INT8U	type, status;
	INT16U	i, j;
	struct YcResult yc;
	//ceshi
	char err[60];
	
	for (i=0; i<FDNum; i++)
	{
		if (!(Fd[i].Flag & FDRENABLE))
			continue;
			
		if (Fd[i].XTime > Fd[i].Mode)
			j = Fd[i].XTime - Fd[i].Mode;
		else
			j = 0;
		j += ITIMESUM;
		type = Fd[i].Flag & FFDRSWTYPE;
		rc = FdrDetectLow(i+1, &yc);

		switch (FdrInfo[i].State)
		{
			case RS_NORMAL:
				if (rc)
				{
					switch (type)
					{
						case FDRTCONCT:
							if (!FdrInfo[i].Temp)
							{
								if (FdrInfo[i].SwYXVal == YX_H)
									FdrInfo[i].Temp = TRUE;
							}
							
							if (yc.FIn && yc.FOut)
							{
								FdrInfo[i].Timer[0]++;
								FdrInfo[i].Timer[1] = 0;
								if (FdrInfo[i].Timer[0] >= ITIME)
								{
									status = FDRTestValid(i+1, RS_NORMAL);
									FDRStateChange(i+1, status);
								}
							}
							else if (yc.FIn || yc.FOut)
							{
								FdrInfo[i].Timer[0] = 0;
								FdrInfo[i].Timer[1]++;
								
								if (FdrInfo[i].Temp && (FdrInfo[i].SwYXVal == YX_F))
								{
									FdrInfo[i].FaultInfo.Type = FDR_A;
									FdrInfo[i].FlagLoc = TRUE;
									FDRStateChange(i+1, RS_LOC);
								}
								
								if (FdrInfo[i].Timer[1] >= (ITIME * 2))
									FDRStateChange(i+1, RS_XTIME);
							}
								
							break;
							
						case FDRTCOMM:
						default:
							if (yc.FIn && yc.FOut)
							{
								FdrInfo[i].Timer[0]++;
								FdrInfo[i].Timer[1] = 0;
								if (FdrInfo[i].Timer[0] >= ITIME)
									FDRStateChange(i+1, RS_CRITICAL);
							}
							else if (yc.FIn || yc.FOut)
							{
								FdrInfo[i].Timer[0] = 0;
								FdrInfo[i].Timer[1]++;
								if (FdrInfo[i].Timer[1] >= ITIME)
								{
									status = FDRTestValid(i+1, RS_NORMAL);
									FDRStateChange(i+1, status);
								}
							}

							break;
					}
				}
				break;
			
			case RS_CRITICAL:
				if (!FdrInfo[i].Temp)
					FdrInfo[i].Timer[2]++;
				if (FdrInfo[i].Timer[2] >= Fd[i].ZTime)
				{
					FdrInfo[i].Temp = TRUE;
					FdrInfo[i].Timer[1] = 0;
					FdrInfo[i].Timer[2] = 0;
					if (FdrInfo[i].SwRelayVal == YX_H)
						FdrSwitchDo(Fd[i].SwYKNo, FALSE);
				}
				
				if (rc)
				{
					switch (type)
					{
						case FDRTCONCT:
							if (!(yc.FIn && yc.FOut))
							{
								FdrInfo[i].Timer[0]++;
								if (FdrInfo[i].Timer[0] >= ITIME)
								{
									FdrInfo[i].FaultInfo.Type = FDR_D;
									FdrInfo[i].FlagLoc = TRUE;
									FDRStateChange(i+1, RS_LOC);
								}
							}
							else
							{
								FdrInfo[i].Timer[0] = 0;
							}
							break;
														
						case FDRTCOMM:	
						default:
							if (yc.FIn ^ yc.FOut)
							{
								FdrInfo[i].Timer[0]++;
								FdrInfo[i].Timer[1] = 0;
								if (FdrInfo[i].Timer[0] >= 2)
									FDRStateChange(i+1, RS_XTIME);
							}
							else
							{
								FdrInfo[i].Timer[0] = 0;
								FdrInfo[i].Timer[1]++;
								if (FdrInfo[i].Timer[1] > Fd[i].ZTime)
								{
									FdrInfo[i].Timer[1] = 0;
									status = FDRTestValid(i+1, RS_CRITICAL);
									FDRStateChange(i+1, status);
								}
							}

							break;
					}
				}				
				break;
			
			case RS_XTIME:
				FdrInfo[i].Timer[0]++;
				
				if (rc)
				{
					switch (type)
					{
						case FDRTCONCT:
							if (yc.FIn && yc.FOut)
								FdrInfo[i].Timer[4]++;
							if (FdrInfo[i].Timer[4] > Fd[i].ZTime)
							{
								FdrInfo[i].FaultInfo.Type = FDR_D;
								FdrInfo[i].FlagLoc = TRUE;
								FDRStateChange(i+1, RS_LOC);
							}
							
							if ((!yc.FIn) && (!yc.FOut))
								FdrInfo[i].Temp = TRUE;
							
							if (FdrInfo[i].Temp)
							{
								FdrInfo[i].Timer[3]++;
								if (FdrInfo[i].Timer[3] < ITIMESUM)
								{
									if ((!yc.FIn) && (!yc.FOut))
									{
										FdrInfo[i].Timer[2]++;
									}
								}
								else
								{
									if (FdrInfo[i].Timer[2] <= Fd[i].ITime)
									{
										FdrInfo[i].Temp = FALSE;
										FdrInfo[i].Timer[1] = 0;
										FdrInfo[i].Timer[2] = 0;
										FdrInfo[i].Timer[3] = 0;
									}
								}
	
								if (FdrInfo[i].Timer[3] < Fd[i].Mode)
								{
									if (yc.FIn || yc.FOut)
										FdrInfo[i].Timer[1]++;
								}
								else
								{
									if ((FdrInfo[i].Timer[2] >= Fd[i].ITime) && (FdrInfo[i].Timer[1] > Fd[i].ZTime))
									{
										FdrInfo[i].FaultInfo.Type = FDR_F | FDR_X;
										FdrInfo[i].FlagLoc = TRUE;
										FDRStateChange(i+1, RS_LOC);
									}
								}
							}
							break;
							
						case FDRTCOMM:	
						default:
							if (FdrInfo[i].Timer[0] < ITIMESUM)
							{
								if (!(yc.FIn && yc.FOut))
								{
									FdrInfo[i].Timer[2]++;
								}
							}
							else
							{
								if (FdrInfo[i].Timer[2] <= Fd[i].ITime)
								{
									sprintf(err, "BUG:瞬间得压为%d0ms...", FdrInfo[i].Timer[2]);
									ErrorInfo(FAID, err);
									FDRStateChange(i+1, RS_CRITICAL);
								}
							}

							if (FdrInfo[i].Timer[0] < Fd[i].Mode)
							{
								if (yc.FIn && yc.FOut)
									FdrInfo[i].Timer[1]++;
							
								if ((FdrInfo[i].Timer[2] >= Fd[i].ITime) && (FdrInfo[i].Timer[1] > Fd[i].ZTime))
								{
									FdrInfo[i].FaultInfo.Type = FDR_F | FDR_X;
									FDRStateChange(i+1, RS_LOC);
								}
							}
							
							if (FdrInfo[i].Timer[0] >= j)
							{
								if (yc.FIn && yc.FOut)
									FdrInfo[i].Timer[3]++;
								
								if (FdrInfo[i].Timer[3] > ITIMESUM)
								{
									FDRStateChange(i+1, RS_CRITICAL);
								}
							}
							
							break;
					}
				}
							
				if (FdrInfo[i].Timer[0] > Fd[i].XTime)
				{
					if (((Fd[i].Flag & FFDRDIR) && yc.FIn) || (!(yc.FIn || yc.FOut)))
					{
						//终止合闸动作
						ErrorInfo(FAID, "BUG:两侧有压(或参数禁止)，合闸闭锁...");
						FdrInfo[i].FaultInfo.Type = FDR_D;
						FdrInfo[i].FlagLoc = TRUE;
						FDRStateChange(i+1, RS_LOC);
					}
					else
					{
						FdrSwitchDo(Fd[i].SwYKNo, TRUE);
						FDRStateChange(i+1, RS_YTIME);
					}
				}
				break;
				
			case RS_YTIME:
				FdrInfo[i].Timer[0]++;
				if (FdrInfo[i].SwYXVal == YX_H)
				{
					FdrInfo[i].Timer[0] += Fd[i].HZFAILTime;
					FdrInfo[i].Temp = TRUE;
				}
				
				if (FdrInfo[i].Timer[0] == Fd[i].HZFAILTime)
				{
					FdrInfo[i].Timer[0] += Fd[i].HZFAILTime;
					FdrInfo[i].Temp = TRUE;
					
					if (FdrInfo[i].SwYXVal != YX_H)
					{
						ErrorInfo(FAID, "BUG:合闸失败，撤销闭锁...");
						FdrSwitchDo(Fd[i].SwYKNo, FALSE);
						FdrInfo[i].FaultInfo.Type = FDR_E;
						FdrInfo[i].FlagLoc = TRUE;
						FDRStateChange(i+1, RS_LOC);
					}
				}
				else
				{
					FdrInfo[i].Timer[0]--;
				}
				
				if (rc)
				{
					if (((!yc.FIn) && (!yc.FOut)) || (FdrInfo[i].SwYXVal == YX_H))
						FdrInfo[i].Temp = TRUE;
						
					if (FdrInfo[i].Temp)
					{
						FdrInfo[i].Timer[1]++;
						if (yc.FIn && yc.FOut)
						{
							FdrInfo[i].Timer[2]++;
						}
					}
				}
				
				if (FdrInfo[i].Timer[2] > Fd[i].ZTime)
				{
					FdrInfo[i].FaultInfo.Type = FDR_F | FDR_Y;
					FdrInfo[i].FlagLoc = TRUE;
					FDRStateChange(i+1, RS_LOC);
				}
					
				if (FdrInfo[i].Timer[1] > Fd[i].YTime)
				{
					FDRStateChange(i+1, RS_NORMAL);
				}
				break;
				
			case RS_LOC:
				if (rc)
				{
					switch (type)
					{
						case FDRTCONCT:
							if (!FdrInfo[i].FlagLoc)
								continue;
							
							if ((!yc.FIn) && (!yc.FOut))
								FdrInfo[i].Temp = TRUE;
							
							if (FdrInfo[i].Temp)
							{