📄 protect_process.c
字号:
#include "MOTOType.h"
#include <math.h>
#include "Applications/inlcudes/hardware_reg.h"
TJDTimingNode OverLoadTn,BlockTn1,BlockTn2,CurrentUnbalanceTn,VoltageShakingTnI,VoltageShakingTnII;
TJDTimingNode VoltageLowTn,PhaseReversedTn, GroundingTn, PT_BrokenTn,Voltage_OverTn,Current_LowTn,StartTn;
extern CALCULATE(void);
void TimeNode_Initialize(void)
{
TimeInitial(&OverLoadTn, *(int *)(JDSettingAdd + offset_OverLoad_Time), 0);
TimeInitial(&BlockTn1, *(int *)(JDSettingAdd + offset_Block_TimeI), 0);
TimeInitial(&BlockTn2, *(int *)(JDSettingAdd + offset_Block_TimeII), 0);
TimeInitial(&CurrentUnbalanceTn, *(int *)(JDSettingAdd + offset_Current_Unbalance_SettingII_Time), 0);
TimeInitial(&VoltageShakingTnI, *(int *)(JDSettingAdd + offset_Voltage_Low_Setting_Time), 0);
TimeInitial(&VoltageShakingTnII, *(int *)(JDSettingAdd + offset_VoltageShaking_Time), 0);
TimeInitial(&VoltageLowTn, *(int *)(JDSettingAdd + offset_Voltage_Low_Setting_Time), 0);
TimeInitial(&PhaseReversedTn, *(int *)(JDSettingAdd + offset_PhaseReversedTime), 0);
TimeInitial(&GroundingTn, *(int *)(JDSettingAdd + offset_I0_Time), 0);
TimeInitial(&PT_BrokenTn, *(int *)(JDSettingAdd + offset_PT_Broken_Time), 0);
TimeInitial(&Voltage_OverTn, *(int *)(JDSettingAdd + offset_Voltage_Over_Setting_Time), 0);
TimeInitial(&Current_LowTn, *(int *)(JDSettingAdd + offset_Current_Low_Setting_Time), 0);
TimeInitial(&StartTn, *(int *)(JDSettingAdd + offset_Start_Setting_Time), 0);
}
void Protect_Process(void)
{
float Phase_Difference = 0; //相序判断中的变量
/*********电流不平衡保护变量**************************************************/
float Current_UnbalanceTemp = 0;
float Current_Unbalance_Value = 0;
/**********************************************************************************/
BOOL PT_Process_Temp = 0; //断相判断中的变量
/*************替换宏的变量****************************************************/
float Average_Voltage = 0;
float Average_Current = 0;
float Max_Current = 0;
float Max_Voltage = 0;
float Min_Current = 0;
float Min_Voltage = 0;
/*************************热过载保护参数定义**********************************/
float I_Eq = 0; // 等效电流
float Te = 0; // 发热时间常数
float k = 0 ; // K*Ie,为最大热平衡电流
float temp = 0 ,x= 0,y = 0,z = 0 ; //计算中间变量
static float r = 0,r_temp = 0; //热容量值
int k1 = 0 ; //正序电流发热系数
int k2 = 0 ; //负序电流发热系数
int p = 0,q = 0;
float Current_Normal = 0 ; //未过负载电流计算值
/*************************判断运行状态********************************/
static int num_Stop_sample = 0;
static int num_Start_sample = 0 ;
/************************************************************************************/
CALCULATE();
Average_Voltage = Voltage_Average;
Average_Current = Current_Average;
Max_Current = Current_Max;
Max_Voltage = Voltage_Max;
Min_Current = Current_Min;
Min_Voltage = Voltage_Min;
/*************************判断运行状态********************************/
if(!Running)
{
if ( Max_Current < *(JDSettingAdd+offset_Current_Stop_Setting ))
{
if( num_Stop_sample<= 1000 )
{
num_Stop_sample++;
}
else
{
num_Stop_sample= 100 ;
}
if( num_Stop_sample > 3 )
{
num_Start_sample = 0;
}
}
else
{
if( num_Start_sample<= 1000)
{
num_Start_sample++;
}
else
{
num_Start_sample= 100 ;
}
if( num_Start_sample > 3 )
{
num_Stop_sample = 0;
}
}
if ( num_Start_sample > 5 )
{
Starting = 1 ;
}
else
{
Starting = 0 ;
}
if( num_Stop_sample > 5 )
{
Stop = 1 ;
}
else
{
Stop = 0 ;
}
}
/*************************启动时间过长保护******************************************/
TimingNodePulse(&StartTn, Starting);
Running = StartTn.level ;
if(Running)
{
Starting = 0 ;
}
Start_TimeUp = StartTn.level && ( Max_Current > *(JDSettingAdd+offset_Current_StartFinish_Setting) ) ;
Alarm_Action( Start_TimeUp && KG_1_1 );
Break_Action( Start_TimeUp && KG_1_2 );
/*************************热过载保护******************************************/
if( KG_2_1 || KG_2_2 )
{
if( Max_Current > *(JDSettingAdd+offset_OverHeat_Current ) )
{
if( Starting )
{
k1 = 0.5 ;
}
else
{
k1 = 1 ;
}
k2 = 6 ;
I_Eq = sqrt(k1* (*(JDInputsAdd+off_I1 )) * (*(JDInputsAdd+off_I1 )) + k2*(*(JDInputsAdd+off_I2 )) * (*(JDInputsAdd+off_I2 )));
Te = *(JDSettingAdd+offset_OverLoad_TeValue);
k = *(JDSettingAdd+offset_OverLoad_Limit);
k *= k ;
temp = I_Eq / *(JDSettingAdd+offset_Current_Rating) ;
temp *=temp ;
x = log( temp / (temp - k ));
y += 1 / x ;
z = 0.001 / *(JDSettingAdd+offset_OverLoad_TeValue);
}
else
{
r *= 1 / exp( z ) ;
}
if( p == 3) //每隔p个点取电压，然后求平均值
{
Current_Normal += Max_Current ;
q++;
p = 0 ;
}
if( q == 5 ) //每q个电压求平均值
{
Current_Normal /= q ;
r_temp = Current_Normal / *(JDSettingAdd+offset_Current_Rating) *(100 - * (JDSettingAdd+offset_ColdVsHeat_Ratio)) ;
q = 0;
}
p++;
if( r < r_temp )
{
r = r_temp ;
}
OverHeat_Alarm = r > *(JDSettingAdd+offset_OverHeat_Alarm_Setting);
OverHeat_Break = r > *(JDSettingAdd+offset_OverHeat_Break_Setting) ;
Restart_Permit = r < *(JDSettingAdd+offset_Restart_Permit_Setting) ;
Alarm_Action( OverHeat_Alarm );
Break_Action( OverHeat_Break );
}
/***************************************过负荷(缺反时限）********************************************/
if( KG_3_1 || KG_3_2 )
{
//躲过启动时间
TimingNodePulse(&OverLoadTn, (Average_Current > *(JDSettingAdd + offset_OverLoad_Current)) && Running);
OverLoad = OverLoadTn.level ;
Alarm_Action( OverLoad && KG_3_1 );
Break_Action( OverLoad && KG_3_2 );
}
/***************************************堵转********************************************/
if( KG_4_1 || KG_4_2 )
{
//躲过启动时间
TimingNodePulse(&BlockTn1, (Average_Current > *(JDSettingAdd + offset_Block_Current))&& Running);
Block_Alarm = BlockTn1.level ;
TimingNodePulse(&BlockTn2, (Average_Current > *(JDSettingAdd + offset_Block_Current))&& Running);
Block_Break = BlockTn2.level ;
Alarm_Action( Block_Alarm && KG_4_1 );
Break_Action( Block_Alarm && KG_4_2 );
}
/********************************** 电流速断保护(短路）*******************************************/
if( KG_5 )
{
if(Starting)
{
Short_Circuit = ( Max_Current > *(JDSettingAdd + offset_ShortCircuit_CurrentI));
}
else
{
Short_Circuit = ( Max_Current > *(JDSettingAdd + offset_ShortCircuit_CurrentII)) ;
}
Break_Action( Block_Alarm );
}
//*************************************** 电流不平衡保护（断相）***************************************/
if( KG_6_1 || KG_6_2 || KG_6_3 )
{
if ( (Max_Current+Min_Current)*0.5 >= Average_Current )
{
Current_UnbalanceTemp = Max_Current- Average_Current ;
}
else
{
Current_UnbalanceTemp = Average_Current - Min_Current ;
}
Current_Unbalance_Value = Current_UnbalanceTemp / Average_Current * 100 ;
if( Current_Unbalance_Value > *(JDSettingAdd + offset_Current_Unbalance_SettingI) )
{
Current_Unbalance_Alarm = 1;
}
else
{
Current_Unbalance_Alarm = 0;
}
TimingNodePulse( &CurrentUnbalanceTn, Current_Unbalance_Value > *(JDSettingAdd + offset_Current_Unbalance_SettingII) );
Current_Unbalance_Break = CurrentUnbalanceTn.level;
if( Current_Unbalance_Value > *(JDSettingAdd + offset_Current_Unbalance_SettingIII) )
{
Line_Broken = 1;
}
else
{
Line_Broken = 0;
}
Alarm_Action( Current_Unbalance_Alarm && KG_6_1 );
Break_Action( Current_Unbalance_Break && KG_6_2 );
Break_Action( Line_Broken && KG_6_3 );
}
/*************************************接地保护（零序）*******************************************/
if( KG_7_1 || KG_7_2)
{
TimingNodePulse(&GroundingTn, *(JDInputsAdd+off_I0) > *(JDSettingAdd+offset_I0));
Grounding = GroundingTn.level;
Alarm_Action( Grounding && KG_7_1 );
Break_Action( Grounding && KG_7_2 );
}
/*************************************相序保护*******************************************/
if( KG_8 )
{
if( (*(JDInputsAdd+off_IA_Phase) - *(JDInputsAdd+off_IB_Phase)) >= 0 )
{
Phase_Difference =( *(JDInputsAdd+off_IA_Phase) - *(JDInputsAdd+off_IB_Phase)) ;
}
else
{
Phase_Difference = (*(JDInputsAdd+off_IA_Phase) - *(JDInputsAdd+off_IB_Phase) + 6.2831853) ;
}
TimingNodePulse(&PhaseReversedTn,(Phase_Difference < 1.570796) || (Phase_Difference > 2.617993));
Phase_Reversed = PhaseReversedTn.level;
Break_Action( Phase_Reversed);
}
/*************************************欠电压保护*******************************************/
if( KG_9_1 || ( !PT_Broken ) )
{
if( !Stop ) //运行的时候投入??
{
TimingNodePulse(&VoltageLowTn, Min_Voltage < *(JDSettingAdd+offset_Voltage_Low_Setting));
Voltage_Low = VoltageLowTn.level;
}
Break_Action( Voltage_Low );
}
/************************************晃电保护(待检验）*******************************************/
if( KG_9_2 || ( !PT_Broken ) )
{
TimingNodePulse(& VoltageShakingTnI, Min_Voltage < *(JDSettingAdd+offset_Voltage_Low_Setting));
Voltage_Shaking = VoltageShakingTnI.level;
TimingNodePulse(&VoltageShakingTnII, Voltage_Shaking);
Voltage_shaking_Over = ((!(VoltageShakingTnII.level )) && (Min_Voltage < *(JDSettingAdd+offset_Voltage_ShakingOver_Setting) ));
Break_Action( Voltage_Shaking );
}
/************************************电压回路断相保护 （TV断线）*******************************************/
if( KG_10 )
{
PT_Process_Temp = (Min_Voltage < *(JDSettingAdd+offset_PTBroken_Voltage_Setting) )&& (Min_Current > *(JDSettingAdd+offset_PTBroken_Current_Setting) ) ;
TimingNodePulse(&PT_BrokenTn, PT_Process_Temp);
PT_Broken = PT_BrokenTn.level;
Alarm_Action( PT_Broken && KG_10 );
Break_Action( PT_Broken && KG_10 );
}
/************* 过电压保护 *******************************************/
if( KG_11 )
{
TimingNodePulse( &Voltage_OverTn, Max_Voltage > *(JDSettingAdd+offset_Voltage_Over_Setting) );
Voltage_Over = Voltage_OverTn.level;
Alarm_Action( Voltage_Over && KG_11 );
Break_Action( Voltage_Over && KG_11 );
}
/************************ 欠电流保护 *************************************/
if( KG_12 )
{
if( !Stop )
{
TimingNodePulse(&Current_LowTn, Min_Current < *(JDSettingAdd+offset_Current_Low_Setting));
Current_Low = Current_LowTn.level;
}
Alarm_Action( Current_Low && KG_12 );
Break_Action( Current_Low && KG_12 );
}
/****************************************************************************************
************************************ 外部故障联锁（待添加)******************************************
*************************************
*************************************** ************************************************/
}
void DataSection_Initialize( void )
{
float Ie , Ue;
*(JDSettingAdd + offset_Current_Rating ) = 10 ;//额定电流 Ie A
*(JDSettingAdd + offset_Voltage_Rating ) = 10 ;//额定电压Ue V
Ie = *(JDSettingAdd + offset_Current_Rating ) ;
Ue = *(JDSettingAdd + offset_Voltage_Rating ) ;
*(JDSettingAdd + offset_OverLoad_Current) = 10 * Ie ;
*(JDSettingAdd + offset_Block_Current) = 6 * Ie ;
*(JDSettingAdd + offset_ShortCircuit_CurrentI ) = 10 * Ie ; //速断一段
*(JDSettingAdd + offset_ShortCircuit_CurrentII ) = 4 * Ie ; //速断二段
*(JDSettingAdd + offset_Current_Unbalance_SettingI) = 15 ; //不平衡报警 %
*(JDSettingAdd + offset_Current_Unbalance_SettingII) = 30 ; //不平衡跳闸%
*(JDSettingAdd + offset_Current_Unbalance_SettingIII ) = 60 ;//断相%
*(JDSettingAdd + offset_I0) = 2 * Ie ; //零序电流
*(JDSettingAdd + offset_Voltage_Low_Setting ) = 0.6 * Ue ; //欠电压（晃电开始）
*(JDSettingAdd + offset_Voltage_Over_Setting ) = 2 * Ue ; //过电压定值
*(JDSettingAdd + offset_Current_Low_Setting ) = 0.6 * Ie ; //欠电流定值
*(JDSettingAdd + offset_Voltage_ShakingOver_Setting) = 0.9 * Ue ; //晃电恢复电压
*(JDSettingAdd + offset_PTBroken_Voltage_Setting ) = 0.1 * Ue ; //PT断线电压定值
*(JDSettingAdd + offset_PTBroken_Current_Setting ) = 0.3 * Ie ; //PT断线电流定值
*(JDSettingAdd + offset_Current_Stop_Setting) = 0.1 * Ie ; //认为电动机停机的电流定值
*(JDSettingAdd + offset_Current_StartFinish_Setting ) = 10 ;//启动完毕电流定值
*(JDSettingAdd + offset_OverLoad_Limit) = 10 ; //过负荷电流系数 k (IB= K*Ie )
//*(JDSettingAdd + offset_Current_Before_OverLoad) = 10; //过负荷前电流 简化程序，设定为 0.8Ie （待验证）
*(JDSettingAdd + offset_OverLoad_TeValue ) = 10; //发热时间常数定值
*(JDSettingAdd + offset_OverHeat_Current ) = 10; //过热保护动作定值
*(JDSettingAdd + offset_ColdVsHeat_Ratio ) = 10; //冷热曲线比
*(JDSettingAdd + offset_OverHeat_Alarm_Setting) = 40; //过热报警定值%
*(JDSettingAdd + offset_OverHeat_Break_Setting) = 95; //过热跳闸定值%
*(JDSettingAdd + offset_Restart_Permit_Setting) = 15; //过热允许重启定值%
*(JDSettingAdd + offset_OverLoad_Time) = 10; //过载时间定值 s
*(JDSettingAdd + offset_Block_TimeI) = 10; //堵转一段时间定值s
*(JDSettingAdd + offset_Block_TimeII) = 10; //堵转二段时间定值s
*(JDSettingAdd + offset_ShortCircuit_TimeII ) = 10; //过电流二段时间定值s
*(JDSettingAdd + offset_Current_Unbalance_SettingII_Time ) = 10; //不平衡二段时间定值s
*(JDSettingAdd + offset_I0_Time) = 10; //零序时间定值s
*(JDSettingAdd + offset_Voltage_Low_Setting_Time ) = 10; //欠电压时间定值 s
*(JDSettingAdd + offset_Voltage_Over_Setting_Time ) = 10; //过电压时间定值s
*(JDSettingAdd + offset_Current_Low_Setting_Time ) = 10; //欠电流时间定謘⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -