9311fdr.c

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

								FdrInfo[i].Timer[0]++;
								if ((!yc.FIn) && (!yc.FOut))
									FdrInfo[i].Timer[1]++;
									
								if (FdrInfo[i].Timer[0] > Fd[i].YTime)
								{
									if (FdrInfo[i].Timer[1] >= Fd[i].YTime * 9 / 10)
									{
										FdrSwitchDo(Fd[i].YKLocNo, FALSE);
										FdrInfo[i].FlagLoc = FALSE;
										FDRStateChange(i+1, RS_NORMAL);
									}
									else
									{
										FdrInfo[i].Temp = 0;
										for(j=0; j<5; j++)
											FdrInfo[i].Timer[j] = 0;
									}
								}
							}
							break;
							
						case FDRTCOMM:	
						default:

							break;
					}
				}
				break;
		}
	}

}

/*------------------------------------------------------------------*/
/*函数名称：FdrDetectYX()											*/
/*函数功能：处理遥信变化											*/
/*------------------------------------------------------------------*/
void FdrDetectYX(void)
{
	INT8U	i, j, rc;
	
	for (i=0; i<FDNum; i++)
	{
		if (!(Fd[i].Flag & FDRENABLE))
			continue;
	
		for (j=0; j<3; j++)
		{
			rc = 0x01<<j;
			if (FdrInfo[i].COSFlag & rc)
			{
				FdrInfo[i].COSFlag ^= rc;
				rc = FDRTestValid(i+1, FdrInfo[i].State);
				FDRStateChange(i+1, rc);
			}
		}

	}
	
}

/*------------------------------------------------------------------*/
/*函数名称：StateChange()											*/
/*函数功能：状态转换，完成相关状态下操作，打印系统信息				*/
/*------------------------------------------------------------------*/
void FDRStateChange(WORD FDIndex, WORD State)
{
	INT8U	j;
	char	errbuf[60];
	struct SysTime_t SystemTime;
	struct DBInfo	info;
		
	memset (errbuf, 0, 60);
	if (FdrInfo[FDIndex-1].State == State)
		return;	

	info.DevID = ROOTID;
	info.Type = FDRLOC;
	info.Num = FDIndex-1;
	if (FdrInfo[FDIndex-1].FlagLoc)
		j = RESET_RETAIN;
	else
		j = RESET_CLR;
	DBWrite(&j, &info);
	
	GetTime((void *)&SystemTime, SYSTIME);

	#ifdef CHINESEINFO
		sprintf(errbuf, "%04d-%02d-%02d %02d:%02d:%02d:%03d 线路 %d %s", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour,SystemTime.Minute, SystemTime.Second, SystemTime.MSecond, FDIndex, FDRInfo[State]);
	#else
		sprintf(errbuf, "%04d-%02d-%02d %02d:%02d:%02d:%03d FD %d %s", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour,SystemTime.Minute, SystemTime.Second, SystemTime.MSecond, FDIndex, FDRInfo[State]);	
	#endif

	ErrorInfo(FAID, errbuf);
	
	//写故障信息
	GetTime((void *)&FdrInfo[FDIndex-1].FaultInfo.Time, ABSTIME);
	FDRWriteInfo(FDIndex);
			
	switch (State)
	{
		case RS_NORMAL:

			break;
				
		case RS_CRITICAL:
	
			break;
				
		case RS_XTIME:
	
			break;
				
		case RS_YTIME:
			break;
				
		case RS_LOC:
			if (FdrInfo[FDIndex-1].SwLocVal == YX_F)
			{
				if (FdrInfo[FDIndex-1].SwRelayVal == YX_H)
					FdrSwitchDo(Fd[FDIndex-1].SwYKNo, FALSE);
			
				FdrSwitchDo(Fd[FDIndex-1].YKLocNo, TRUE);
			}
			break;
	
	}
	
	if (FdrInfo[FDIndex-1].State == RS_LOC)
		FdrInfo[FDIndex-1].FlagLoc = FALSE;
		
	FdrInfo[FDIndex-1].State = State;
	FdrInfo[FDIndex-1].PreState = State;
	FdrInfo[FDIndex-1].Temp = FALSE;
	for(j=0; j<5; j++)
		FdrInfo[FDIndex-1].Timer[j] = 0;
}


/*------------------------------------------------------------------*/
/*函数名称：FdrRenewYx()											*/
/*函数功能：读取数据库遥信，更新实时遥信值							*/
/*输入说明：														*/
/*输出说明：														*/
/*------------------------------------------------------------------*/
BOOL FdrRenewYx(void)
{
	BOOL	rc;
	INT8U	i, dd[16];
	struct DBInfo	info;

	info.DevID = ROOTID;
	info.Type = YXDATA;
	info.Start = 0;
	info.Num = MyCfg.BINum;
	rc =DBRead(dd, &info);
	if (!rc)
		return (FALSE);

	for (i=0; i<FDNum; i++)
	{
		if (FdrInfo[i].SwYXVal != dd[DEFBINUM * i + 0])
		{
			FdrInfo[i].COSFlag |= 0x01;
			FdrInfo[i].SwYXVal = dd[DEFBINUM * i + 0];
		}
		if (FdrInfo[i].SwRelayVal != dd[DEFBINUM * i + YXRELAYNO])
		{
//			FdrInfo[i].COSFlag |= 0x02;
			FdrInfo[i].SwRelayVal = dd[DEFBINUM * i + YXRELAYNO];
		}
		if (FdrInfo[i].SwLocVal != dd[DEFBINUM * i + YXLOCNO])
		{
			FdrInfo[i].COSFlag |= 0x04;
			FdrInfo[i].SwLocVal = dd[DEFBINUM * i + YXLOCNO];
		}
	}

	return (TRUE);
}

/*------------------------------------------------------------------*/
/*函数名称：FdrDetectU()											*/
/*函数功能：检测是否失压											*/
/*输入说明：FDIndex--馈线号											*/
/*输出说明：两相电压判断值，得压FALSE，失压TRUE						*/
/*------------------------------------------------------------------*/
BOOL FdrDetectLow(INT16U FDIndex, struct YcResult *Rc)
{
	INT8U	i;
	
	if ((FDIndex > FDNum) || (FDIndex == 0))
		return FALSE;
	
	i = FDIndex - 1;
	
	if (TempYc[i*FDRYCNUM + 0] >= Fd[i].LowULimit)
		Rc->FIn = FALSE;
	else
		Rc->FIn = TRUE;
		
	if (TempYc[i*FDRYCNUM + 1] >= Fd[i].LowULimit)
		Rc->FOut = FALSE;
	else
		Rc->FOut = TRUE;	

	return (TRUE);
}

/*------------------------------------------------------------------*/
/*函数名称：FdrSwitchDo()											*/
/*函数功能：完成开关动作，合/分，延时保证命令的执行					*/
/*------------------------------------------------------------------*/
void FdrSwitchDo(INT8U No, BOOL ON_OFF)
{
	BOOL	bSuccess;
	INT8U	i;
	char	errbuf[60];
	struct SysTime_t SystemTime;
	
	if (YKOnCounter || ACTING)
	{
		YKMem.No = No;
		YKMem.ON_OFF = ON_OFF;
		YKMem.Flag = TRUE;
		return ;
	}
	else
		memset (&YKMem, 0, sizeof (struct YKDelayMem));

	//开关动作
	bSuccess = YKSet(No, ON_OFF, 0);
	if(bSuccess)
		bSuccess = YKExe(No, ON_OFF, 0);
			
	memset (errbuf, 0, 60);
	GetTime((void *)&SystemTime, SYSTIME);
	
	if ((No % DEFYKNUM) == SWLOCNO)
	{
		if (ON_OFF)
			i = 2;
		else
			i = 3;
	}
	else
	{
		if (ON_OFF)
			i = 0;
		else
			i = 1;		
	}
	

	#ifdef CHINESEINFO
		if (bSuccess)
		{
			sprintf(errbuf, "%04d-%02d-%02d %02d:%02d:%02d:%03d 线路 %d %s成功(遥控号 = %d)", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour,SystemTime.Minute, SystemTime.Second, SystemTime.MSecond, No/DEFYKNUM+1, FDRSwDo[i], No);
		}
		else
		{
			sprintf(errbuf, "%04d-%02d-%02d %02d:%02d:%02d:%03d 线路 %d %s失败(遥控号 = %d)", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour,SystemTime.Minute, SystemTime.Second, SystemTime.MSecond, No/DEFYKNUM+1, FDRSwDo[i], No);
		}
	#else
		if (bSuccess)
		{
			sprintf(errbuf, "%04d-%02d-%02d %02d:%02d:%02d:%03d FD %d %s Success(YKNO = %d)", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour,SystemTime.Minute, SystemTime.Second, SystemTime.MSecond, No/DEFYKNUM+1, FDRSwDo[i], No);	
		}
		else
		{
			sprintf(errbuf, "%04d-%02d-%02d %02d:%02d:%02d:%03d FD %d %s Fail(YKNO = %d)", SystemTime.Year, SystemTime.Month, SystemTime.Day, SystemTime.Hour,SystemTime.Minute, SystemTime.Second, SystemTime.MSecond, No/DEFYKNUM+1, FDRSwDo[i], No);	
		}
	#endif

	ErrorInfo(FAID, errbuf);
}

/*------------------------------------------------------------------*/
/*函数名称：FdrReadYc(void)											*/
/*函数功能：读取相应的中间遥测值									*/
/*------------------------------------------------------------------*/
void FdrReadYc(void)
{
	INT8U	i, j;
	
	for (i=0; i<FDNum; i++)
	{
		if (Fd[i].Flag & FFDRDIRACT)
		{
			TempYc[i*FDRYCNUM + 0] = YCTemp[i].FData[1].Rms2;
			TempYc[i*FDRYCNUM + 1] = YCTemp[i].FData[0].Rms2;
		}
		else
		{
			for (j=0; j<2; j++)
			{
				TempYc[i*FDRYCNUM + j] = YCTemp[i].FData[j].Rms2;
			}
		}
	}
}

/*------------------------------------------------------------------*/
/*函数名称：FDRTestValid(void)										*/
/*函数功能：判断开关逻辑有效型（辅助功能）							*/
/*------------------------------------------------------------------*/
INT8U FDRTestValid(INT16U FDIndex, INT8U Status)
{
	INT8U	i;
	INT8U	type, rc;
	struct YcResult yc;
	
	i = FDIndex - 1;
	rc = 0xFF;
	FdrReadYc();
	FdrDetectLow(FDIndex, &yc);
	type = Fd[i].Flag & FFDRSWTYPE;
	
	if (FdrInfo[i].SwLocVal == YX_H)
	{
		FdrInfo[i].FaultInfo.Type = FDR_A;
		rc = RS_LOC;
	}
	else
	{
		switch (FdrInfo[i].State)
		{
			case RS_NORMAL:
			case RS_CRITICAL:
			case RS_XTIME:
				switch (type)
				{
					case FDRTCONCT:
						if ((!yc.FIn) && (!yc.FOut))
						{
							rc = RS_NORMAL;
						}
						else if (yc.FIn && yc.FOut)
						{
							rc = RS_CRITICAL;
						}
						else
						{
							FdrInfo[i].FaultInfo.Type = FDR_A;
							FdrInfo[i].FlagLoc = TRUE;
							rc = RS_LOC;
						}
						break;
						
					case FDRTCOMM:
					default:	
						if ((!yc.FIn) && (!yc.FOut))
						{
							if (FdrInfo[i].SwYXVal == YX_H)
							{
								rc = RS_NORMAL;
							}
							else
							{
								FdrInfo[i].FaultInfo.Type = FDR_D;
								rc = RS_LOC;
							}
						}
						else if (yc.FIn && yc.FOut)
						{
							rc = RS_CRITICAL;
						}
						else
						{
							if (FdrInfo[i].SwYXVal == YX_H)
							{
								//err
							}
							else
							{
								rc = RS_XTIME;
							}
						}
						break;
				}
				break;
			
			case RS_YTIME:
				rc = Status;
				break;
				
			case RS_LOC:
					if ((!yc.FIn) && (!yc.FOut))
					{
						rc = RS_NORMAL;
					}
					else if (yc.FIn && yc.FOut)
					{
						rc = RS_CRITICAL;
					}
					else
					{
						rc = RS_XTIME;
					}
					
				break;
			
			default:
				rc = Status;
				break;
		}
	}	
		
		
		
/*
	else if (FdrInfo[i].SwYXVal == YX_H)
	{
		if (FdrInfo[i].SwRelayVal == YX_H)
		{
			rc = RS_YTIME;
		}
		else
		{
			//err
		}
	}
	else
	{
		switch (type)
		{
			case FDRTCONCT:
				if ((!yc.FIn) && (!yc.FOut))
				{
					rc = RS_NORMAL;
				}
				else if (yc.FIn && yc.FOut)
				{
					rc = RS_CRITICAL;
				}
				else
				{
					if (Status == RS_LOC)
					{
						rc = RS_XTIME;
					}
					else
					{
						FdrInfo[i].FaultInfo.Type = FDR_A;
						FdrInfo[i].FlagLoc = TRUE;
						rc = RS_LOC;
					}
		
				}
				break;
				
			case FDRTCOMM:
			default:
				if ((!yc.FIn) && (!yc.FOut))
				{
					if (FdrInfo[i].SwYXVal == YX_H)
					{
						rc = RS_NORMAL;
					}
					else
					{
						if (Status == RS_LOC)
							rc = RS_NORMAL;
						else
						{
							FdrInfo[i].FaultInfo.Type = FDR_E;
							rc = RS_LOC;
						}
					}
				}
				else if ((!yc.FIn) || (!yc.FOut))
				{
					if (FdrInfo[i].SwYXVal == YX_H)
					{
						//err
					}
					else
					{
						rc = RS_XTIME;
					}
				}
				else
				{
					rc = RS_CRITICAL;
				}
				break;
		}
	}
*/	
	
	//err
	if (rc == 0xFF)
	{
		if (FdrInfo[i].PreState != rc)
		{
			ErrorInfo(FAID, "BUG:逻辑错误!请立即处理...");
			FdrInfo[i].FaultInfo.Type = FDR_E;
			FdrInfo[i].PreState = rc;
		}
		rc = Status;
	}
	else if (rc != Status)
	{
		ErrorInfo(FAID, "BUG:时序转换...");
		FdrInfo[i].PreState = rc;
	}
	
	return (rc);
}

/*------------------------------------------------------------------*/
/*函数名称：FDRWriteInfo()										*/
/*函数功能：写故障遥信												*/
/*------------------------------------------------------------------*/
void FDRWriteInfo(INT16U FDIndex)
{
	BOOL	rc = FALSE;
	INT8U	i;
	INT16U	SoftBINo;
	
	i = FDIndex-1;
	
	if (FdrInfo[i].FaultInfo.Type == 0)
		return;
	
	FDRResetInfo(FDIndex);
	FdrInfo[i].FaultInfo.BakType = FdrInfo[i].FaultInfo.Type;
	FdrInfo[i].FaultInfo.ResetCounter = FDRRESETTIME;
	
	SoftBINo = FDRGetSoftBINo((INT16U*)&FdrInfo[i].FaultInfo.Type);
	while (SoftBINo)
	{
		SOE[HEAD].No = FDOTHERYXNUM + (i * FASOFTBINUM) + SoftBINo;
		SOE[HEAD].Status =  YX_H;
		SOE[HEAD].Time = FdrInfo[i].FaultInfo.Time;
		HEAD++;
		if (HEAD >= SOE_NUM_TMP)
			HEAD = 0;
		rc = TRUE;
				
		SoftBINo = FDRGetSoftBINo((INT16U*)&FdrInfo[i].FaultInfo.Type);
	}
	
	if (rc)
		SOETask(ROOTID, TRUE);
}

/*------------------------------------------------------------------*/
/*函数名称：FDRResetInfo()										*/
/*函数功能：复位故障遥信											*/
/*------------------------------------------------------------------*/
void FDRResetInfo(INT16U FDIndex)
{
	BOOL	rc = FALSE;
	INT8U	i;
	INT16U	SoftBINo;
	struct AbsTime_t Time;
	
	i = FDIndex - 1;
	
	if (FdrInfo[i].FaultInfo.BakType == 0)
		return;
	FdrInfo[i].FaultInfo.ResetCounter = 0;
	
	SoftBINo = FDRGetSoftBINo((INT16U*)&FdrInfo[i].FaultInfo.BakType);
	while (SoftBINo)
	{
		SOE[HEAD].No = FDOTHERYXNUM + (i * FASOFTBINUM) + SoftBINo;
		SOE[HEAD].Status =  YX_F;
		GetTime((void *)&Time, ABSTIME);
		SOE[HEAD].Time = Time;
		HEAD++;
		if (HEAD >= SOE_NUM_TMP)
			HEAD = 0;
		rc = TRUE;
		
		SoftBINo = FDRGetSoftBINo((INT16U*)&FdrInfo[i].FaultInfo.BakType);
	}
	
	if (rc)
		SOETask(ROOTID, TRUE);		
}

/*------------------------------------------------------------------*/
/*函数名称：GetSoftBINo(INT16U *FaultType)							*/
/*函数功能：获得故障遥信号											*/
/*------------------------------------------------------------------*/
INT16U FDRGetSoftBINo(INT16U *FaultType)
{

	if ((*FaultType) & FDR_F)
	{
		(*FaultType) &= (~FDR_F);
		return (FAFAULTD);
	}
	
	if ((*FaultType) & FDR_Y)
	{
		(*FaultType) &= (~FDR_Y);
		return (FAAFOREVER);
	}
	
	if ((*FaultType) & FDR_X)
	{
		(*FaultType) &= (~FDR_X);
		return (FABFOREVER);
	}
	
	if ((*FaultType) & FDR_D)
	{
		(*FaultType) &= (~FDR_D);
		return (FACFOREVER);
	}
	
	if ((*FaultType) & FDR_A)
	{
		(*FaultType) &= (~FDR_A);
		return (FAOFOREVER);
	}

	if ((*FaultType) & FDR_E)
	{
		(*FaultType) &= (~FDR_E);
		return (FAAINSTANT);
	}

	if ((*FaultType) & FDR_H)
	{
		(*FaultType) &= (~FDR_H);
		return (FABINSTANT);
	}
	
	return (0);	
}