protectoc3_current.c

电力系统中的保护装置全部代码

float   Uab_real,Uab_imaginary,Ubc_real,Ubc_imaginary,Uca_real,Uca_imaginary;
float   Ia_real,Ia_imaginary,Ib_real,Ib_imaginary,Ic_real,Ic_imaginary;
float   Angle_Mode;
static  UNSIGNED Remember_Flag = 0,Remember_Result;
extern  UNSIGNED	Uabcnt,Ubccnt,Ucacnt;

extern  PROTECT   protect_PT;
UNSIGNED          *PTDXBZ,*XGBH;

extern  void back_calculate(unsigned AIChn, float *real, float *imaginary);
extern  UNSIGNED DIRECT(float U_real,float U_imaginary,float I_real,float I_imaginary,float Angle_Mode);

#endif
// ----------------------------------------------------- // 

    pProtect = ptr;
#if	CTYPE
//指针赋值
    PTDXBZ        =    &protect_PT.pro_reserve1;//ＰＴ断线标志  
    XGBH          =    &protect_PT.pro_reserve2;//相关保护投退
#endif    
//////取定值
// ----------------------------------------------------- // 
//定值区号
    SetZoneNum    =    iLONC_SetZoneNum;
    pSets         =    pProtect->pro_setting; 
//电流          
    Current_Set    =    pSets->set_value_zone[SetZoneNum];
    pSets++;
//时间        
    Time_Set       =    pSets->set_value_zone[SetZoneNum];
    pSets++;

#if	CTYPE
//电压
    Voltage_Set     =    pSets->set_value_zone[SetZoneNum];
    pSets++;
//方向角
    Angle_Mode      =    pSets->set_value_zone[SetZoneNum];
    pSets++; 	     
//电压控制字
    Voltage_Word    =    pSets->set_value_zone[SetZoneNum];
    pSets++;
//方向控制字
    Direct_Word     =    pSets->set_value_zone[SetZoneNum];
    pSets++;	
#endif

//////实时数据
// ----------------------------------------------------- // 
//数据通道
    Ia_Value    =    AIChn[PIa_Chn].chl_value1;
    Ib_Value    =    AIChn[PIb_Chn].chl_value1;
    Ic_Value    =    AIChn[PIc_Chn].chl_value1;
   //------------------------------------------------//
//数据传递
    pValue      =    pProtect->pro_run_data;  
   //------------------------------------------------// 
// Ａ相电流  
    pValue->value_measure    =    Ia_Value;
    pValue++;        
// Ｂ相电流  
    pValue->value_measure    =    Ib_Value;
    pValue++;           
// Ｃ相电流  
    pValue->value_measure    =    Ic_Value;
    pValue++; 
#if	CTYPE
// ＡB相电压  
    pValue->value_measure    =    Uab;
    pValue++;        
// ＢC相电压  
    pValue->value_measure    =    Ubc;
    pValue++;           
// ＣA相电压  
    pValue->value_measure    =    Uca;
    pValue++;  
#endif         
   //------------------------------------------------//

//////保护逻辑
// ----------------------------------------------------- // 

//压板指针
    pProtect->pro_jumper = OC_III_jumper;
    pJumper = pProtect->pro_jumper; 

//保护退
    if(!pJumper->jum_status)				
    {
        ClearFlag(pProtect);
        return; 
    } 
#if	CTYPE
    if(*PTDXBZ && (*XGBH == 0))
        return;
    if(*PTDXBZ)
    {
        Voltage_Word = 0;    
        Direct_Word = 0;
    }    
#endif    
//保护投
//电流元件
    if(Ia_Value < Current_Set && Ib_Value < Current_Set && Ic_Value < Current_Set)
    {
        NoStartup(pProtect);
        pProtect->pro_reserve5 = TMD_System_Clock;
        return;
    }      

//去干扰
    if(EraseBurr(pProtect))
        return;

#if	CTYPE
//电压闭锁元件
    if(Voltage_Word)
    {
        i = 1;
        if((Ia_Value >= Current_Set) && ((Uab < Voltage_Set) || (Uca < Voltage_Set)))
        i = 0;
        if(i)
        {
            if((Ib_Value >= Current_Set) && ((Uab < Voltage_Set) || (Ubc < Voltage_Set)))
            i = 0;
        }    
        if(i)
        {
            if((Ic_Value >= Current_Set) && ((Ubc < Voltage_Set) || (Uca < Voltage_Set)))
            i = 0; 
        }                   
        if(i)
        return;
    }
        
//方向闭锁元件
    if(Direct_Word)
    {
        i = 0;
//A相电流
        if(Ia_Value > Current_Set)
        {
            if(Ubc > ZEROVOLTAGE)
            {
    	        Ubccnt++;
    	        if(Ubccnt > 10)
    	        {
    	            Remember_Flag = 0;
//当前电压    	    
    	            Ia_real      = AIChn[PIa_Chn].chla_fundamental_real;
                    Ia_imaginary = AIChn[PIa_Chn].chla_fundamental_imaginary;
                    Ub_real      = AIChn[Ub_Chn].chla_fundamental_real;
                    Ub_imaginary = AIChn[Ub_Chn].chla_fundamental_imaginary;
                    Uc_real      = AIChn[Uc_Chn].chla_fundamental_real;
                    Uc_imaginary = AIChn[Uc_Chn].chla_fundamental_imaginary;
            
                    Ubc_real = Ub_real - Uc_real;
                    Ubc_imaginary = Ub_imaginary -Uc_imaginary;
            
                    i = DIRECT(Ubc_real,Ubc_imaginary,Ia_real,Ia_imaginary,Angle_Mode);
    	        }
    	        else
    	            i = Remember_Result;
            }
    
            else
            {
    	        Ubccnt = 0;
    	        if(Remember_Flag)
    	            i = Remember_Result;
    	        else
                {
                    Ia_real      = AIChn[PIa_Chn].chla_fundamental_real;
                    Ia_imaginary = AIChn[PIa_Chn].chla_fundamental_imaginary;
//记忆电压            
                    back_calculate(Ub_Chn, &Ub_real, &Ub_imaginary);
                    back_calculate(Uc_Chn, &Uc_real, &Uc_imaginary);
                        
                    Ubc_real = Ub_real - Uc_real;
                    Ubc_imaginary = Ub_imaginary -Uc_imaginary;
            
                    i = DIRECT(Ubc_real,Ubc_imaginary,Ia_real,Ia_imaginary,Angle_Mode);
            
                    Remember_Result = i;
                    Remember_Flag = 1;    
                }    
            }        	
        }
//B相电流
        if(!i)
        {
            if(Ib_Value > Current_Set)
            {
                if(Uca > ZEROVOLTAGE)
                {
                    Ucacnt++;
                    if(Ucacnt > 10)
                    {
                        Remember_Flag = 0;
    	    
                        Ib_real      = AIChn[PIb_Chn].chla_fundamental_real;
                        Ib_imaginary = AIChn[PIb_Chn].chla_fundamental_imaginary;
                        Uc_real      = AIChn[Uc_Chn].chla_fundamental_real;
                        Uc_imaginary = AIChn[Uc_Chn].chla_fundamental_imaginary;
                        Ua_real      = AIChn[Ua_Chn].chla_fundamental_real;
                        Ua_imaginary = AIChn[Ua_Chn].chla_fundamental_imaginary;
            
                        Uca_real = Uc_real - Ua_real;
                        Uca_imaginary = Uc_imaginary -Ua_imaginary;
            
                        i = DIRECT(Uca_real,Uca_imaginary,Ib_real,Ib_imaginary,Angle_Mode);
    	            }
    	            else
    	                i = Remember_Result;
                }
    
                else
                {
    	            Ubccnt = 0;
    	            if(Remember_Flag)
    	                i = Remember_Result;
    	            else
                    {
                        Ib_real      = AIChn[PIb_Chn].chla_fundamental_real;
                        Ib_imaginary = AIChn[PIb_Chn].chla_fundamental_imaginary;
            
                        back_calculate(Ua_Chn, &Ua_real, &Ua_imaginary);
                        back_calculate(Uc_Chn, &Uc_real, &Uc_imaginary);
                        
                        Uca_real = Uc_real - Ua_real;
                        Uca_imaginary = Uc_imaginary -Ua_imaginary;
            
                        i = DIRECT(Uca_real,Uca_imaginary,Ib_real,Ib_imaginary,Angle_Mode);
            
                        Remember_Result = i;
                        Remember_Flag = 1;    
                    }    
                }        	
            }
        }
//C相电流
        if(!i)
        {
            if(Ic_Value > Current_Set)
            {
                if(Uab > ZEROVOLTAGE)
                {
                    Uabcnt++;
                    if(Uabcnt > 10)
                    {
                        Remember_Flag = 0;
    	    
                        Ic_real      = AIChn[PIc_Chn].chla_fundamental_real;
                        Ic_imaginary = AIChn[PIc_Chn].chla_fundamental_imaginary;
                        Ua_real      = AIChn[Ua_Chn].chla_fundamental_real;
                        Ua_imaginary = AIChn[Ua_Chn].chla_fundamental_imaginary;
                        Ub_real      = AIChn[Ub_Chn].chla_fundamental_real;
                        Ub_imaginary = AIChn[Ub_Chn].chla_fundamental_imaginary;
            
                        Uab_real = Ua_real - Ub_real;
                        Uab_imaginary = Ua_imaginary -Ub_imaginary;
            
                        i = DIRECT(Uab_real,Uab_imaginary,Ic_real,Ic_imaginary,Angle_Mode);
    	            }
    	            else
    	                i = Remember_Result;
                }
    
                else
                {
    	            Uabcnt = 0;
    	            if(Remember_Flag)
    	                i = Remember_Result;
    	            else
                    {
                        Ic_real      = AIChn[PIc_Chn].chla_fundamental_real;
                        Ic_imaginary = AIChn[PIc_Chn].chla_fundamental_imaginary;
            
                        back_calculate(Ua_Chn, &Ua_real, &Ua_imaginary);
                        back_calculate(Ub_Chn, &Ub_real, &Ub_imaginary);
                        
                        Uab_real = Ua_real - Ub_real;
                        Uab_imaginary = Ua_imaginary -Ub_imaginary;
            
                        i = DIRECT(Uab_real,Uab_imaginary,Ic_real,Ic_imaginary,Angle_Mode);
            
                        Remember_Result = i;
                        Remember_Flag = 1;    
                    }    
                }        	
            }
        }

        if(!i)return;
    }    
        #endif               		

//启动
    if(StartPro(pProtect))
        return;

//时间元件
    if(TimeWait(pProtect,Time_Set)) 
        return;
	        	
//动作元件
    pProtect->pro_pickup_flag = 1;
    Pickup();			//跳闸子程序
    pProtect->pro_reserve5 = TMD_System_Clock - pProtect->pro_reserve5;//相对时间
		    
//报告
    pReport = &OC3_Report;
//SOE				    	
    pSoe = &pReport->pro_report_soe;
   //------------------------------------------------//             	  	
    pSoe->Relative_Time = pProtect->pro_reserve5;
    READ_DEC_TIME(&pSoe->Year);
//    pSoe->Fault_Number = SOENumber++;
   //------------------------------------------------// 
//动作值
    pValue = pReport->pro_report_data;
   //------------------------------------------------// 
    pValue -> value_measure    =    Ia_Value;
    pValue++; 
                    
    pValue -> value_measure    =    Ib_Value;
    pValue++;
    
    pValue -> value_measure    =    Ic_Value;
    pValue++; 
   //------------------------------------------------//
    pReport->mmi_flag = MMIDISPLAY + MMIPICKUP;
    Fill_Report(pReport);

}