T536_DTU/dtu/dtu_main_t536/app/oc.c

/******************************************************************************
版权所有：
文件名称：	Oc.c
文件版本：	01.01
创建作者：	xxxxxx
创建日期：	2012-03-28
功能说明：	过流保护
其它说明：
修改记录：
*/
/*------------------------------- 头文件 --------------------------------------
 */
#include "head.h"

/*------------------------------- 宏定义 --------------------------------------
 */

/*------------------------------ 类型结构 -------------------------------------
 */

/*------------------------------ 全局变量 -------------------------------------
 */

/*------------------------------ 函数声明 -------------------------------------
 */

/*------------------------------ 外部函数 -------------------------------------
外部函数供其它实体文件引用，必须仔细检查传入参数的合法性.
*/

bool CalDir_A(int sw, bool bQD, bool bInv)
{
    int indexU, indexI;
    bool bzx = false;
    indexU = PUB_AC_UBC1;
    indexI = UI_SW_INDEX(sw, SW_AC_IA);
    if (!tPT.uPT1DX.bFlag.bPTYC && (g_ui[indexU].m2[0] > pRunSet->dVOL10V_SQR) && bQD) // UBC > 10V
    {
        if (!bInv) // 电流反向
        {
            bzx = PowerDirectionalRelay(g_ui[indexU].ri.r, g_ui[indexU].ri.i, g_ui[indexU].m2[0], g_ui[indexI].ri.r, g_ui[indexI].ri.i, g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN0, COS0, SIN300, COS300); // 计算A相电流方向
        }
        else
        {
            bzx = PowerDirectionalRelay(g_ui[indexU].ri.r, g_ui[indexU].ri.i, g_ui[indexU].m2[0], g_ui[indexI].ri.r, g_ui[indexI].ri.i, g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN180, COS180, SIN120, COS120); // 计算A相电流方向
        }
    }
    return bzx;
}

bool CalDir_B(int sw, bool bQD, bool bInv)
{
    int indexU, indexI;
    bool bzx = false;
    indexU = PUB_AC_UCA1;
    indexI = UI_SW_INDEX(sw, SW_AC_IB);
    if (!tPT.uPT1DX.bFlag.bPTYC && (g_ui[indexU].m2[0] > pRunSet->dVOL10V_SQR) && bQD) // UCA > 10V
    {
        if (!bInv)
        {
            bzx = PowerDirectionalRelay(g_ui[indexU].ri.r, g_ui[indexU].ri.i, g_ui[indexU].m2[0], g_ui[indexI].ri.r, g_ui[indexI].ri.i, g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN0, COS0, SIN300, COS300); // 计算B相电流方向
        }
        else
        {
            bzx = PowerDirectionalRelay(g_ui[indexU].ri.r, g_ui[indexU].ri.i, g_ui[indexU].m2[0], g_ui[indexI].ri.r, g_ui[indexI].ri.i, g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN180, COS180, SIN120, COS120); // 计算B相电流方向
        }
    }
    return bzx;
}

bool CalDir_C(int sw, bool bQD, bool bInv)
{
    int indexU, indexI;
    bool bzx = false;
    indexU = PUB_AC_UAB1;
    indexI = UI_SW_INDEX(sw, SW_AC_IC);
    if (!tPT.uPT1DX.bFlag.bPTYC && (g_ui[indexU].m2[0] > pRunSet->dVOL10V_SQR) && bQD) // UAB > 10V
    {
        if (!bInv)
        {
            bzx = PowerDirectionalRelay(g_ui[indexU].ri.r, g_ui[indexU].ri.i, g_ui[indexU].m2[0], g_ui[indexI].ri.r, g_ui[indexI].ri.i, g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN0, COS0, SIN300, COS300); // 计算C相电流方向
        }
        else
        {
            bzx = PowerDirectionalRelay(g_ui[indexU].ri.r, g_ui[indexU].ri.i, g_ui[indexU].m2[0], g_ui[indexI].ri.r, g_ui[indexI].ri.i, g_ui[indexI].m2[0], pRunSet->dVOL10V_SQR, pRunSet->dIWL_SQR[sw], SIN180, COS180, SIN120, COS120); // 计算C相电流方向
        }
    }
    return bzx;
}

bool pro_check_bh_all(int sw)
{
    if (soe_check(EV_GL1TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GL2TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GL3TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX1TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX2TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX3TZ + sw * EV_SW_NUM) == true)
        return true;

    if (soe_check(EV_GLJS + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LXJS + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_FA_GL_TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_FA_LX_TZ + sw * EV_SW_NUM) == true)
        return true;
#ifdef SOE_RECORD_DELAY
    if (g_soe_queue.fzsoe_wait_flag)
        return true;
#endif
    return false;
}

bool pro_check_gl_all(int sw)
{
    if (soe_check(EV_GL1TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GL2TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GL3TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GL1GJ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GL2GJ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GL3GJ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_GLJS + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_FA_GL_TZ + sw * EV_SW_NUM) == true)
        return true;
#ifdef SOE_RECORD_DELAY
    if (g_soe_queue.fzsoe_wait_flag)
        return true;
#endif
    return false;
}

bool pro_check_lx_all(int sw)
{
    if (soe_check(EV_LX1GJ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX2GJ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX3GJ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX1TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX2TZ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_LX3TZ + sw * EV_SW_NUM) == true)
        return true;

    if (soe_check(EV_LXJS + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_FA_LX_TZ + sw * EV_SW_NUM) == true)
        return true;
#ifdef SOE_RECORD_DELAY
    if (g_soe_queue.fzsoe_wait_flag)
        return true;
#endif

#ifdef FUN_JDXX
    if (soe_check(EV_JDXX_GJ + sw * EV_SW_NUM) == true)
        return true;
    if (soe_check(EV_JDXX_TZ + sw * EV_SW_NUM) == true)
        return true;
#endif

    return false;
}

bool pro_check_fault_all(int sw)
{
    bool ret;
    ret = pro_check_gl_all(sw) || pro_check_lx_all(sw);
    return ret;
}

void pro_check_gl_abc(int sw, DWORD i_set, DWORD I1, DWORD I2, DWORD I3)
{
    bool bIa, bIb, bIc;
    int ui_begin;
    TRELAY_T *pR = &g_tRelay[sw];
    ui_begin = UI_SW_INDEX_BEGIN(sw);

    bIa = (g_ui[ui_begin + SW_AC_IA].m2[0] > i_set) ? true : false;
    bIb = (g_ui[ui_begin + SW_AC_IB].m2[0] > i_set) ? true : false;
    bIc = (g_ui[ui_begin + SW_AC_IC].m2[0] > i_set) ? true : false;

    if (bIa && bIb && bIc)
    {
        if (soe_check(EV_IABC_GL + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_IABC_GL + sw * EV_SW_NUM, 1, I1, I2, I3);
            pR->bYcRefresh.bAGl = true;
            pR->bYcRefresh.bBGl = true;
            pR->bYcRefresh.bCGl = true;
        }
    }
    else if (bIa && bIb)
    {
        if (soe_check(EV_IAB_GL + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_IAB_GL + sw * EV_SW_NUM, 1, I1, I2, 0);
            pR->bYcRefresh.bAGl = true;
            pR->bYcRefresh.bBGl = true;
        }
    }
    else if (bIa && bIc)
    {
        if (soe_check(EV_ICA_GL + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_ICA_GL + sw * EV_SW_NUM, 1, I1, I3, 0);
            pR->bYcRefresh.bAGl = true;
            pR->bYcRefresh.bCGl = true;
        }
    }
    else if (bIb && bIc)
    {
        if (soe_check(EV_IBC_GL + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_IBC_GL + sw * EV_SW_NUM, 1, I2, I3, 0);
            pR->bYcRefresh.bBGl = true;
            pR->bYcRefresh.bCGl = true;
        }
    }
    else if (bIa)
    {
        if (soe_check(EV_IA_GL + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_IA_GL + sw * EV_SW_NUM, 1, I1, 0, 0);
            pR->bYcRefresh.bAGl = true;
        }
    }
    else if (bIb)
    {
        if (soe_check(EV_IB_GL + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_IB_GL + sw * EV_SW_NUM, 1, I2, 0, 0);
            pR->bYcRefresh.bBGl = true;
        }
    }
    else if (bIc)
    {
        if (soe_check(EV_IC_GL + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_IC_GL + sw * EV_SW_NUM, 1, I3, 0, 0);
            pR->bYcRefresh.bCGl = true;
        }
    }
}

void pro_check_fd_gl_abc(int sw, DWORD i_set, DWORD I1, DWORD I2, DWORD I3, int soe_no)
{
    bool bIa, bIb, bIc;
    int ui_begin;
    u32 code;

    ui_begin = UI_SW_INDEX_BEGIN(sw);

    bIa = (g_ui[ui_begin + SW_AC_IA].m2[0] > i_set) ? true : false;
    bIb = (g_ui[ui_begin + SW_AC_IB].m2[0] > i_set) ? true : false;
    bIc = (g_ui[ui_begin + SW_AC_IC].m2[0] > i_set) ? true : false;

    // soe_no--;
    if ((soe_no == EV_GL1TZ) || (soe_no == EV_GL1GJ))
        code = EV_GL1_IA + sw * EV_SW_NUM;
    else if ((soe_no == EV_GL2TZ) || (soe_no == EV_GL2GJ))
        code = EV_GL2_IA + sw * EV_SW_NUM;
    else if ((soe_no == EV_GL3TZ) || (soe_no == EV_GL3GJ))
        code = EV_GL3_IA + sw * EV_SW_NUM;
    else
        return;

    if (bIa)
    {
        if (soe_check(code) == false)
        {
            soe_record_ev(code, 1, I1, 0, 0);
        }
    }
    if (bIb)
    {
        if (soe_check(code + 1) == false)
        {
            soe_record_ev(code + 1, 1, I2, 0, 0);
        }
    }
    if (bIc)
    {
        if (soe_check(code + 2) == false)
        {
            soe_record_ev(code + 2, 1, I3, 0, 0);
        }
    }
}

void pro_rst_fd_gl_event(int sw, int soe_no)
{
    u32 code;

    if (soe_no == EV_GL1TZ)
        code = EV_GL1_IA;
    else if (soe_no == EV_GL2TZ)
        code = EV_GL2_IA;
    else if (soe_no == EV_GL3TZ)
        code = EV_GL3_IA;
    else
        return;

    if (soe_check(code + sw * EV_SW_NUM) == true)
    {
        soe_record_ev(code + sw * EV_SW_NUM, 0, 0, 0, 0);
    }

    if (soe_check(code + sw * EV_SW_NUM + 1) == true)
    {
        soe_record_ev(code + sw * EV_SW_NUM + 1, 0, 0, 0, 0);
    }

    if (soe_check(code + sw * EV_SW_NUM + 2) == true)
    {
        soe_record_ev(code + sw * EV_SW_NUM + 2, 0, 0, 0, 0);
    }
}

void pro_rst_event(int sw, int soe_no)
{
    if (soe_check(soe_no + sw * EV_SW_NUM) == true)
    {
        soe_record_ev(soe_no + sw * EV_SW_NUM, 0, 0, 0, 0);
    }
}

void xb_bs_soe(int sw, u32 dStep)
{
    int i;
    bool bxb_bs[BHOC_NUMBER] = {false}, xb_soe = false;

    for (i = BH_GL1; i < BHOC_NUMBER; i++)
    {
        TOC_T *poc = &g_tRelay[sw].tOC[i];

        if ((i == BH_GL1) || (i == BH_GL2) || (i == BH_GL3) || (i == BH_GLJS))
            bxb_bs[i] = poc->sta.bFlag.bXBbs;
        else
            bxb_bs[i] = false;

        RunTR(&poc->tXBTime, bxb_bs[i], dStep);
        RunTR(&poc->tXBQD25ms, bxb_bs[i], dStep);

        if ((poc->tXBTime.boolTrip) && (poc->tXBQD25ms.boolTrip))
        {
            xb_soe = true;
            break;
        }
    }

    if (xb_soe)
    {
        if (soe_check(EV_XBBS + sw * EV_SW_NUM) == false)
        {
            soe_record_ev(EV_XBBS + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
    }
    else
    {
        if (soe_check(EV_XBBS + sw * EV_SW_NUM) == true)
        {
            soe_record_ev(EV_XBBS + sw * EV_SW_NUM, 0, 0, 0, 0);
        }
    }
}

void Pro_OC(int sw, u32 dStep, int oc, int soe_no)
{
    bool bQDD, bTrip;
    TOC_T *poc = &g_tRelay[sw].tOC[oc];
    OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
    u16 soeno = soe_no + sw * EV_SW_NUM;
    bool bfxmz, bxbbs, bxb;
    int ui_begin;
    bool bIazx, bIbzx, bIczx;
    bool bdyenable = true; // 低电压闭锁
    bool bTz = false;

    // 电流启动
    ui_begin = UI_SW_INDEX_BEGIN(sw);
    poc->sta.bFlag.bIaQD = OverRelay(g_ui[ui_begin + SW_AC_IA].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIaQD);
    poc->sta.bFlag.bIbQD = OverRelay(g_ui[ui_begin + SW_AC_IB].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIbQD);
    poc->sta.bFlag.bIcQD = OverRelay(g_ui[ui_begin + SW_AC_IC].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIcQD);

    bIazx = CalDir_A(sw, poc->sta.bFlag.bIaQD && pSet->bDir, pRunSet->tSwSet[sw].bTT_DIR_Inv); // 方向计算
    bIbzx = CalDir_B(sw, poc->sta.bFlag.bIbQD && pSet->bDir, pRunSet->tSwSet[sw].bTT_DIR_Inv);
    bIczx = CalDir_C(sw, poc->sta.bFlag.bIcQD && pSet->bDir, pRunSet->tSwSet[sw].bTT_DIR_Inv);

    bxb = pRunSet->tSwSet[sw].bTT_bh_xbbs;
    poc->sta.bFlag.bIaxb = bxb && XBCalc(sw, SW_AC_IA, pRunSet->tSwSet[sw].d_bh_xbcoe, poc->sta.bFlag.bIaQD);
    poc->sta.bFlag.bIbxb = bxb && XBCalc(sw, SW_AC_IB, pRunSet->tSwSet[sw].d_bh_xbcoe, poc->sta.bFlag.bIbQD);
    poc->sta.bFlag.bIcxb = bxb && XBCalc(sw, SW_AC_IC, pRunSet->tSwSet[sw].d_bh_xbcoe, poc->sta.bFlag.bIcQD);

    bfxmz = (tPT.uPT1DX.bFlag.bPTYC) // PT异常，自动满足方向
            || (!pSet->bDir)         // 方向不投入
            || bIazx || bIbzx || bIczx;
    bQDD = poc->sta.bFlag.bIaQD || poc->sta.bFlag.bIbQD || poc->sta.bFlag.bIcQD;
    bxbbs = (poc->sta.bFlag.bIaxb || poc->sta.bFlag.bIbxb || poc->sta.bFlag.bIcxb); // 谐波闭锁

#ifndef OCI_XB_0MS
    if (BH_ALL_EN(sw))
    {
        if ((oc == BH_GL1) || (oc == BH_GL2) || (oc == BH_GL3))
        {
            poc->sta.bFlag.bXBbs = (BH_ALL_EN(sw) && (pSet->bTz || pSet->bGj) && bQDD) && bxbbs;
            if (oc == BH_GL1)
                xb_bs_soe(g_protect.sw, dStep);
        }
    }
#endif

    poc->sta.bFlag.bddyQD = LowRelay(g_sw_pub.m2_min[2], pRunSet->dU_DDYBS, pRunSet->dU_DDYBS, poc->sta.bFlag.bddyQD);
    bdyenable = (!pRunSet->bTT_DDYBS)                                 // 低电压闭锁未投入，自动满足
                || (poc->sta.bFlag.bddyQD && !tPT.uPT1DX.bFlag.bPTYC) // 低电压满足，TV正常
                || (tPT.uPT1DX.bFlag.bPTYC);                          // PT异常，低电压自动满足

    poc->sta.bFlag.bQD = (BH_ALL_EN(sw) && (pSet->bTz || pSet->bGj) && bQDD && bdyenable && (!bxbbs) && bfxmz);

    if (poc->sta.bFlag.bQD) // 幅值启动
    {
        if (!poc->sta.bFlag.bQDWave)
        {
            rcd_start(sw, RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); // 录波类型：跳闸类
            poc->sta.bFlag.bQDWave = true;
        }
    }
    else
    {
        poc->sta.bFlag.bQDWave = false;
    }
#ifdef EV_GL_STATR
    gl_start_soe_set(poc->sta.bFlag.bQD, sw, soe_no + 2); // 过流启动SOE
#endif

    RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
    RunTR(&poc->tQD25ms, poc->sta.bFlag.bQD, dStep);

    // 如果速断时间到，启动时间未到，调用幅值启动加速模块
    if (poc->sta.bFlag.bQD && poc->tQDTime.boolTrip && !poc->tQD25ms.boolTrip)
    {
        if (protect_amp_qd_js(sw))
        {
            // 预置25ms，让下个循环再出口
            PreSetTime(&poc->tQD25ms, T_25ms);
#ifdef CPU_FUXI
            // FUXI平台等待下一个循环会导致偶尔动作时间超40ms，改为不等待，本循环处理完
            poc->tQD25ms.boolTrip = 1;
#endif
        }
    }

    bTrip = poc->tQDTime.boolTrip && poc->tQD25ms.boolTrip;
    poc->sta.bFlag.bGj = bTrip && pSet->bGj; // 告警
    poc->sta.bFlag.bGjEvent = poc->sta.bFlag.bGj;

    // 过流三段闭锁重合闸
    poc->sta.bFlag.bBSCH = poc->sta.bFlag.bTz && !pRunSet->tSwSet[sw].dT_ch_gl_tt;

    if (bTrip) // 条件满足，置动作灯
    {
        poc->sta.bFlag.bTripBak = true;
        // poc->sta.bFlag.bDzLed = true;
    }
    poc->sta.bFlag.bTz = bTrip && pSet->bTz;

#ifdef SOE_RECORD_DELAY
    bTz = poc->sta.bFlag.bTz && soe_check(EV_TZFAIL + sw * EV_SW_NUM) == false;
#else
    bTz = poc->sta.bFlag.bTz;
#endif

#ifdef YX_RESET_TIME
    {
        bool bY1;
        // 故障遥信延时复归
        bY1 = (!poc->sta.bFlag.bGj) && poc->sta.bFlag.bGjEvent;
        RunTR(&poc->tGjEvRstTime, bY1, dStep);
        poc->sta.bFlag.bGjEvent = poc->sta.bFlag.bGj || (!poc->tGjEvRstTime.boolTrip && bY1);

        bY1 = (!poc->sta.bFlag.bTz) && poc->sta.bFlag.bTzEvent;
        RunTR(&poc->tTzEvRstTime, bY1, dStep);
        poc->sta.bFlag.bTzEvent = poc->sta.bFlag.bTz || (!poc->tTzEvRstTime.boolTrip && bY1);
    }
    bTz = poc->sta.bFlag.bTzEvent;
#endif

    if (bTz)
    {
        gl_soe_set_clr(1, sw, soeno, pSet->dI, false);
        if (soe_check(EV_BH_FAULT + sw * EV_SW_NUM) == false) // 保护总
        {
            soe_record_ev(EV_BH_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
        poc->sta.bFlag.bDzLed = true;
    }
    else
    {
        gl_soe_set_clr(0, sw, soeno, pSet->dI, false);
        if (pro_check_bh_all(sw) == false)
        {
            pro_rst_event(sw, EV_BH_FAULT); // 保护总
        }
    }

    // 告警记录及出口
    if (poc->sta.bFlag.bGjEvent)
    {
        gl_soe_set_clr(1, sw, soeno + 1, pSet->dI, BH_WAVETIME_EN(pSet->dT)); // 大于150毫秒，出口也启动录波
        if (poc->sta.bFlag.bDzLed == false)
        {
            poc->sta.bFlag.bGjLed = true;
        }
    }
    else
    {
        gl_soe_set_clr(0, sw, soeno + 1, pSet->dI, false);
    }
}

void Pro_LX(int sw, u32 dStep, int oc, int soe_no)
{
    bool bQDD, bQDD1, bTrip;
    TOC_T *poc = &g_tRelay[sw].tOC[oc];
    OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
    u16 soeno = soe_no + sw * EV_SW_NUM;
    int ui_begin;
    bool bTz = false;
    TRELAY_T *pR = &g_tRelay[sw];

    ui_begin = UI_SW_INDEX_BEGIN(sw);
    // 电流启动
    bQDD = OverRelay(g_ui[ui_begin + SW_AC_I0].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD);

    bQDD1 = OverRelay(g_ui[PUB_AC_U01].m2[0], pRunSet->dU_U0BS, pRunSet->dU_U0BS, false);

    poc->sta.bFlag.bQD = (BH_ALL_EN(sw)) && (pSet->bTz || pSet->bGj) && bQDD && ((bQDD1 && pRunSet->bTT_U0BS) || (!pRunSet->bTT_U0BS));

    if (poc->sta.bFlag.bQD) // 幅值启动
    {
        if (!poc->sta.bFlag.bQDWave)
        {
            rcd_start(sw, RECORD_TYPE_LXGL, RECORD_LEN_TZQD); // 录波类型：跳闸类
            poc->sta.bFlag.bQDWave = true;
        }
    }
    else
    {
        poc->sta.bFlag.bQDWave = false;
    }
#ifdef EV_GL_STATR
    lx_start_soe_set(poc->sta.bFlag.bQD, sw, soe_no + 2); // 过流启动SOE
#endif

    RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
    RunTR(&poc->tQD25ms, poc->sta.bFlag.bQD, dStep);

    // 如果时间到，启动时间未到，调用幅值启动加速模块
    if (poc->sta.bFlag.bQD && poc->tQDTime.boolTrip && !poc->tQD25ms.boolTrip)
    {
        if (protect_amp_lx_js(sw))
        {
            // 预置25ms，让下个循环再出口
            PreSetTime(&poc->tQD25ms, T_25ms);
#ifdef CPU_FUXI
            // FUXI平台等待下一个循环会导致偶尔动作时间超40ms，改为不等待，本循环处理完
            poc->tQD25ms.boolTrip = 1;
#endif
        }
    }

    bTrip = poc->tQDTime.boolTrip && poc->tQD25ms.boolTrip;
    poc->sta.bFlag.bGj = bTrip && pSet->bGj; // 告警
    poc->sta.bFlag.bTz = bTrip && pSet->bTz; // 出口
    // 零序闭锁重合闸
    poc->sta.bFlag.bBSCH = poc->sta.bFlag.bTz && !pRunSet->tSwSet[sw].dT_ch_jd_tt;

    if (bTrip) // 条件满足，置动作灯
    {
        poc->sta.bFlag.bTripBak = true;
        // poc->sta.bFlag.bDzLed = true;
    }

#ifdef SOE_RECORD_DELAY
    bTz = poc->sta.bFlag.bTz && soe_check(EV_TZFAIL + sw * EV_SW_NUM) == false;
#else
    bTz = poc->sta.bFlag.bTz;
#endif

#ifdef YX_RESET_TIME
    {
        bool bY1;
        // 故障遥信延时复归
        bY1 = (!poc->sta.bFlag.bGj) && poc->sta.bFlag.bGjEvent;
        RunTR(&poc->tGjEvRstTime, bY1, dStep);
        poc->sta.bFlag.bGjEvent = poc->sta.bFlag.bGj || (!poc->tGjEvRstTime.boolTrip && bY1);

        bY1 = (!poc->sta.bFlag.bTz) && poc->sta.bFlag.bTzEvent;
        RunTR(&poc->tTzEvRstTime, bY1, dStep);
        poc->sta.bFlag.bTzEvent = poc->sta.bFlag.bTz || (!poc->tTzEvRstTime.boolTrip && bY1);
    }
    bTz = poc->sta.bFlag.bTzEvent;
#endif

    if (bTz)
    {
        poc->sta.bFlag.bDzLed = true;
        if (soe_check(soeno) == false)
        {
            DWORD I0, U0;
            I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
            U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);
            soe_record_ev(soeno, 1, I0, U0, 0);
            // rcd_start(sw,RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
        }

        if (soe_check(EV_LX_FAULT + sw * EV_SW_NUM) == false) // 零序总
        {
            soe_record_ev(EV_LX_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
            pR->bYcRefresh.bLx = true;
        }
        if (soe_check(EV_BH_FAULT + sw * EV_SW_NUM) == false) // 保护总
        {
            soe_record_ev(EV_BH_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
        if (soe_check(EV_ALL_FAULT + sw * EV_SW_NUM) == false) // 保护总
        {
            soe_record_ev(EV_ALL_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
    }
    else
    {
        if (soe_check(soeno) == true)
        {
            soe_record_ev(soeno, 0, 0, 0, 0);
        }

        if (pro_check_lx_all(sw) == false)
        {
            pro_rst_event(sw, EV_LX_FAULT); // 零序总
        }
        if (pro_check_bh_all(sw) == false)
        {
            pro_rst_event(sw, EV_BH_FAULT); // 保护总
        }
        if (pro_check_fault_all(sw) == false)
        {
            pro_rst_event(sw, EV_ALL_FAULT); // 事故总
        }
    }

    // 告警记录及出口
    if (poc->sta.bFlag.bGj)
    {
        if (poc->sta.bFlag.bDzLed == false)
        {
            poc->sta.bFlag.bGjLed = true;
        }
        if (soe_check(soeno + 1) == false)
        {
            DWORD I0, U0;
            I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
            U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);
            soe_record_ev(soeno + 1, 1, I0, U0, 0);
            if (BH_WAVETIME_EN(pSet->dT))
                rcd_start(sw, RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
        }
        if (soe_check(EV_LX_FAULT + sw * EV_SW_NUM) == false) // 零序总
        {
            soe_record_ev(EV_LX_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
            pR->bYcRefresh.bLx = true;
        }
        if (soe_check(EV_ALL_FAULT + sw * EV_SW_NUM) == false) // 保护总
        {
            soe_record_ev(EV_ALL_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
    }
    else
    {
        if (soe_check(soeno + 1) == true)
        {
            soe_record_ev(soeno + 1, 0, 0, 0, 0);
        }

        if (pro_check_lx_all(sw) == false)
        {
            pro_rst_event(sw, EV_LX_FAULT); // 零序总
        }
        if (pro_check_fault_all(sw) == false)
        {
            pro_rst_event(sw, EV_ALL_FAULT); // 事故总
        }
    }
}
/**************************************************************************
函数名称：Pro_Accheck
函数版本：1.00
作者：    保护产品部
创建日期：2007.10.15

函数功能说明：加速功能块
输入参数：
其他输入:
输出参数：
返回值：
***************************************************************************/
void Pro_Accheck(int sw, u32 dStep, int oc, int soe_no)
{
    bool bQDD, bTrip;
    bool bJS3, bJS4, bJS5;
    bool bY1, bY2;
    TOC_T *poc = &g_tRelay[sw].tOC[oc];
    OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
    u16 soeno = soe_no + sw * EV_SW_NUM;
    bool bxbbs, benable;
    int ui_begin;
    DWORD U0;
    TRELAY_T *pR = &g_tRelay[sw];

    ui_begin = UI_SW_INDEX_BEGIN(sw);

    U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);

    if (oc == BH_GLJS || oc == BH_LXJS)
    {
        benable = BH_ALL_EN(sw);
    }
    else
    {
        benable = FA_ALL_EN(sw);
    }

    // 电流启动
    if (oc == BH_GLJS || oc == FA_GL)
    {
        bool bxb;
        DWORD xbcoe; // 谐波系数

        if (oc == BH_GLJS)
        {
            bxb = pRunSet->tSwSet[sw].bTT_bh_xbbs;
            xbcoe = pRunSet->tSwSet[sw].d_bh_xbcoe;
        }
        else
        {
            bxb = pRunSet->tSwSet[sw].bTT_fa_xbbs;
            xbcoe = pRunSet->tSwSet[sw].d_fa_xbcoe;
        }
        poc->sta.bFlag.bIaQD = OverRelay(g_ui[ui_begin + SW_AC_IA].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIaQD);
        poc->sta.bFlag.bIbQD = OverRelay(g_ui[ui_begin + SW_AC_IB].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIbQD);
        poc->sta.bFlag.bIcQD = OverRelay(g_ui[ui_begin + SW_AC_IC].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bIcQD);

        poc->sta.bFlag.bIaxb = bxb && XBCalc(sw, SW_AC_IA, xbcoe, poc->sta.bFlag.bIaQD);
        poc->sta.bFlag.bIbxb = bxb && XBCalc(sw, SW_AC_IB, xbcoe, poc->sta.bFlag.bIbQD);
        poc->sta.bFlag.bIcxb = bxb && XBCalc(sw, SW_AC_IC, xbcoe, poc->sta.bFlag.bIcQD);
        bQDD = poc->sta.bFlag.bIaQD || poc->sta.bFlag.bIbQD || poc->sta.bFlag.bIcQD;
        bxbbs = poc->sta.bFlag.bIaxb || poc->sta.bFlag.bIbxb || poc->sta.bFlag.bIcxb; // 谐波闭锁

        if (BH_ALL_EN(sw))
        {
            if (oc == BH_GLJS)
            {
                poc->sta.bFlag.bXBbs = (BH_ALL_EN(sw) && (pSet->bTz || pSet->bGj) && bQDD) && bxbbs;
                // xb_bs_soe(g_protect.sw,dStep);
            }
        }
    }
    else // 零序加速或FA合后零序过流跳闸
    {
        // 零序电流过量继电器
        bY1 = OverRelay(g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD);
        // 零序电压过量继电器
        // bY2 = OverRelay(g_ui[PUB_AC_U01].m2[0], pRunSet->dU_U0BS, pRunSet->dU_U0BS, false);
        bY2 = true;
        bQDD = bY1 && ((bY2 && pRunSet->bTT_U0BS) || (!pRunSet->bTT_U0BS));
        bxbbs = false;
    }
    // 检查合闸加速标
    if (oc == BH_GLJS || oc == BH_LXJS)
    {
        bJS3 = g_tRelay[sw].tCHZ.sta.bFlag.bCHJS        // 重合加速标
               || g_tRelay[sw].tSWST.uSWST.bFlag.bSHJS; // 手合加速标
    }
    else
    {
        bJS3 = g_tRelay[sw].tSWST.uSWST.bFlag.bSDJS // 上电加速
                                                    //|| g_tRelay[sw].tSWST.uSWST.bFlag.bSHJS; 	// 手合加速标
            ;
    }

    poc->sta.bFlag.bQD = (benable && (pSet->bTz || pSet->bGj) && bQDD) && (!bxbbs); // 谐波闭锁
    // 加速标保持
    bJS4 = bJS3 || poc->sta.bFlag.bJSBC;

    // 后加速启动条件满足
    bJS5 = poc->sta.bFlag.bQD && bJS4;

    // 合闸加速标保持
    poc->sta.bFlag.bJSBC = bJS5 && bJS4;

    if (bJS5) // 幅值启动
    {
        if (!poc->sta.bFlag.bQDWave)
        {
            if (oc == BH_GLJS || oc == FA_GL)
            {
                rcd_start(sw, RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); // 录波类型：跳闸类
            }
            else
            {
                rcd_start(sw, RECORD_TYPE_LXGL, RECORD_LEN_TZQD); // 录波类型：跳闸类
            }
            poc->sta.bFlag.bQDWave = true;
        }
    }
    else
    {
        poc->sta.bFlag.bQDWave = false;
    }
    RunTR(&poc->tQDTime, bJS5, dStep);
    RunTR(&poc->tQD25ms, bJS5, dStep);

    // 如果加速时间到，启动时间未到，调用幅值启动加速模块
    if ((oc == BH_GLJS || oc == FA_GL || BH_LXJS) && (poc->sta.bFlag.bQD && poc->tQDTime.boolTrip && !poc->tQD25ms.boolTrip))
    {
        if (oc == BH_GLJS || oc == FA_GL)
        {
            if (protect_amp_qd_js(sw))
            {
                // 预置25ms，让下个循环再出口
                PreSetTime(&poc->tQD25ms, T_25ms);
            }
        }
        else
        {
            if (protect_amp_lx_js(sw))
            {
                // 预置25ms，让下个循环再出口
                PreSetTime(&poc->tQD25ms, T_25ms);
            }
        }
    }

    bTrip = poc->tQDTime.boolTrip && poc->tQD25ms.boolTrip;

    poc->sta.bFlag.bTz = bTrip; //

    if (bTrip) // 条件满足，置动作灯
    {
        poc->sta.bFlag.bTripBak = true;
        // poc->sta.bFlag.bDzLed = true;
    }

#ifdef YX_RESET_TIME
    // 故障遥信延时复归
    bY1 = (!poc->sta.bFlag.bTz) && poc->sta.bFlag.bTzEvent;
    RunTR(&poc->tTzEvRstTime, bY1, dStep);
    poc->sta.bFlag.bTzEvent = poc->sta.bFlag.bTz || (!poc->tTzEvRstTime.boolTrip && bY1);
#endif

    // 出口记录及出口
    if (oc == BH_GLJS || oc == FA_GL)
    {
#ifdef YX_RESET_TIME
        if (poc->sta.bFlag.bTzEvent)
#else
        if (poc->sta.bFlag.bTz)
#endif
        {
            poc->sta.bFlag.bDzLed = true;
            gl_soe_set_clr(1, sw, soeno, pSet->dI, BH_WAVETIME_EN(pSet->dT));
            if (soe_check(EV_BH_FAULT + sw * EV_SW_NUM) == false) // 保护总
            {
                soe_record_ev(EV_BH_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
            }
            if (oc == FA_GL)
            {
                if (soe_check(EV_HHGZ + sw * EV_SW_NUM) == false && pRunSet->tSwSet[sw].bTT_fa_gzbshz)
                {
                    soe_record_ev(EV_HHGZ + sw * EV_SW_NUM, 1, 0, 0, 0);
                }
            }
        }
        else
        {
            gl_soe_set_clr(0, sw, soeno, pSet->dI, false);
            if (pro_check_bh_all(sw) == false)
            {
                pro_rst_event(sw, EV_BH_FAULT); // 保护总
            }
        }
    }
    else // 零序加速
    {
        // 出口记录及出口
#ifdef YX_RESET_TIME
        if (poc->sta.bFlag.bTzEvent)
#else
        if (poc->sta.bFlag.bTz)
#endif
        {
            poc->sta.bFlag.bDzLed = true;
            if (soe_check(soeno) == false)
            {
                DWORD I0;
                I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
                // U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);
                soe_record_ev(soeno, 1, I0, U0, 0);
                if (BH_WAVETIME_EN(pSet->dT))
                    rcd_start(sw, RECORD_TYPE_LXGL, RECORD_LEN_TZQD);
            }

            if (soe_check(EV_LX_FAULT + sw * EV_SW_NUM) == false) // 零序总
            {
                soe_record_ev(EV_LX_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
                pR->bYcRefresh.bLx = true;
            }
            if (soe_check(EV_BH_FAULT + sw * EV_SW_NUM) == false) // 保护总
            {
                soe_record_ev(EV_BH_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
            }
            if (soe_check(EV_ALL_FAULT + sw * EV_SW_NUM) == false) // 故障总
            {
                soe_record_ev(EV_ALL_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
            }
            if (oc == FA_LX)
            {
                if (soe_check(EV_HHGZ + sw * EV_SW_NUM) == false && pRunSet->tSwSet[sw].bTT_fa_gzbshz)
                {
                    soe_record_ev(EV_HHGZ + sw * EV_SW_NUM, 1, 0, 0, 0);
                }
            }
        }
        else
        {
            if (soe_check(soeno) == true)
            {
                soe_record_ev(soeno, 0, 0, 0, 0);
            }
            if (pro_check_lx_all(sw) == false)
            {
                pro_rst_event(sw, EV_LX_FAULT); // 零序总
            }
            if (pro_check_bh_all(sw) == false)
            {
                pro_rst_event(sw, EV_BH_FAULT); // 保护总
            }
            if (pro_check_fault_all(sw) == false)
            {
                pro_rst_event(sw, EV_ALL_FAULT); // 故障总
            }
        }
    }
}

/******************************************************************************
函数名称：	Pro_BSTZ
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2015-10-23
函数说明：	大电流闭锁分闸，用于负荷开关，以免过切断容量跳闸
参数说明：	无
返回值：  	成功返回0.
修改记录：
*/
void Pro_BSTZ(int sw, u32 dStep, int oc, int soe_no)
{

    bool bQDD, bTrip;
    TOC_T *poc = &g_tRelay[sw].tOC[oc];
    OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
    u16 soeno = soe_no + sw * EV_SW_NUM;
    // 电流启动
    bQDD = OverRelay(g_sw[sw].m2_max, pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD);
    poc->sta.bFlag.bQD = (BH_ALL_EN(sw) // 现有程序FA模式下已处理遮断，所以只需要BH模式投入此功能
                          && (pSet->bTz || pSet->bGj) && bQDD);
    if (poc->sta.bFlag.bQD) // 幅值启动
    {
#if 0
		if(!poc->sta.bFlag.bQDWave)
		{
			rcd_start(sw,RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
			poc->sta.bFlag.bQDWave=true;
		}
#endif
    }

    RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
    bTrip = poc->tQDTime.boolTrip;
    poc->sta.bFlag.bTz = bTrip && pSet->bTz;
    g_tRelay[sw].bBSTZ = bTrip && pSet->bTz;
    if (bTrip) // 条件满足，置动作灯
    {
        poc->sta.bFlag.bTripBak = true;
        poc->sta.bFlag.bDzLed = true;
    }
    if (!BH_ALL_EN(sw))
    {
        return;
    }
    // 出口记录及出口
    if (poc->sta.bFlag.bTz)
    {
        if (soe_check(soeno) == false)
        {
            int ui_begin;
            DWORD Ia, Ib, Ic;
            ui_begin = UI_SW_INDEX_BEGIN(sw);
            Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
            Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
            Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
            soe_record_ev(soeno, 1, Ia, Ib, Ic);
            // if(BH_WAVETIME_EN(pSet->dT))rcd_start(sw,RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); 	//录波类型：跳闸类
        }
    }
    else
    {
        if (soe_check(soeno) == true)
        {
            soe_record_ev(soeno, 0, 0, 0, 0);
        }
    }
}

/***********************************
函数名称：	Pro_over_limit_i
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2015-10-23
函数说明：	电流越限
参数说明：	无
返回值：  	成功返回0.
修改记录：
*/
void Pro_over_i(int sw, u32 dStep, int oc, int soe_no)
{
    bool bQDD, bTrip;
    int ui_begin;
    DWORD Ia, Ib, Ic;

#ifdef YX_RESET_TIME
    bool by1;
#endif

    TOC_T *poc = &g_tRelay[sw].tOC[oc];
    OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
    u16 soeno = soe_no + sw * EV_SW_NUM;
    // 电流启动
    bQDD = OverRelay(g_sw[sw].m2_max, pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD);
    poc->sta.bFlag.bQD = (pSet->bTz || pSet->bGj) && bQDD;
    RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
    bTrip = poc->tQDTime.boolTrip; // 告警
    poc->sta.bFlag.bGj = bTrip;    // 告警

#ifdef YX_RESET_TIME
    // 故障遥信延时复归
    by1 = (!poc->sta.bFlag.bGj) && poc->sta.bFlag.bGjEvent;
    RunTR(&poc->tGjEvRstTime, by1, dStep);
    poc->sta.bFlag.bGjEvent = poc->sta.bFlag.bGj || (!poc->tGjEvRstTime.boolTrip && by1);
#endif

    // 告警记录及出口
    if (bTrip) // 条件满足，置动作灯
    {
        poc->sta.bFlag.bDzLed = true;
    }

    if (poc->sta.bFlag.bGj)
    {
        // gz_soe_set_clr(1,sw,soeno,pSet->dI);
        if (soe_check(soeno))
            return;
        ui_begin = UI_SW_INDEX_BEGIN(sw);
        Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
        Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
        Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
        soe_record_ev(soeno, 1, Ia, Ib, Ic);
    }
    else
    {
        // gz_soe_set_clr(0,sw,soeno,pSet->dI);
        if (!soe_check(soeno))
            return;

        soe_record_ev(soeno, 0, 0, 0, 0);
    }
}

void Pro_over_i0(int sw, u32 dStep, int oc, int soe_no)
{
    bool bQDD, bTrip;

#ifdef YX_RESET_TIME
    bool by1;
#endif

    TOC_T *poc = &g_tRelay[sw].tOC[oc];
    OC_SET *pSet = &pRunSet->tSwSet[sw].toc[oc];
    u16 soeno = soe_no + sw * EV_SW_NUM;
    // 电流启动
    bQDD = OverRelay(g_ui[UI_SW_INDEX(sw, SW_AC_I0)].m2[0], pSet->dI, pSet->dI_fh, poc->sta.bFlag.bQD);
    poc->sta.bFlag.bQD = (pSet->bTz || pSet->bGj) && bQDD;
    RunTR(&poc->tQDTime, poc->sta.bFlag.bQD, dStep);
    bTrip = poc->tQDTime.boolTrip; // 告警
    poc->sta.bFlag.bGj = bTrip;    // 告警

#ifdef YX_RESET_TIME
    // 故障遥信延时复归
    by1 = (!poc->sta.bFlag.bGj) && poc->sta.bFlag.bGjEvent;
    RunTR(&poc->tGjEvRstTime, by1, dStep);
    poc->sta.bFlag.bGjEvent = poc->sta.bFlag.bGj || (!poc->tGjEvRstTime.boolTrip && by1);
#endif

    if (bTrip) // 条件满足，置动作灯
    {
        poc->sta.bFlag.bDzLed = true;
    }

    if (poc->sta.bFlag.bGj)
    {
        if (soe_check(soeno) == false)
        {
            int ui_begin;
            DWORD I0;
            ui_begin = UI_SW_INDEX_BEGIN(sw);
            I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
            soe_record_ev(soeno, 1, I0, 0, 0);
        }
    }
    else
    {
        if (soe_check(soeno) == true)
        {
            soe_record_ev(soeno, 0, 0, 0, 0);
        }
    }
}

#ifdef EV_GL_STATR
void gl_start_soe_set(u8 set_clr, int sw, u16 soe_no)
{
    int ui_begin;
    DWORD Ia, Ib, Ic;
    ui_begin = UI_SW_INDEX_BEGIN(sw);
    Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
    Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
    Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
    ui_begin = UI_SW_INDEX_BEGIN(sw);
    if (soe_check(soe_no) != set_clr)
    {
        soe_record_ev(soe_no, set_clr, Ia, Ib, Ic);
    }
}

void lx_start_soe_set(u8 set_clr, int sw, u16 soe_no)
{
    int ui_begin;
    DWORD I0, U0;
    ui_begin = UI_SW_INDEX_BEGIN(sw);
    I0 = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_I0].m2[0]), 256, g_ui[ui_begin + SW_AC_I0].m2_factor_k);
    U0 = _Mul_Div_U(sqrt_32fix(g_ui[PUB_AC_U01].m2[0]), 256, g_ui[PUB_AC_U01].m2_factor_k);
    if (soe_check(soe_no) != set_clr)
    {
        soe_record_ev(soe_no, set_clr, U0, I0, 0);
    }
}
#endif

/******************************************************************************
函数名称：	gl_soe_set_clr
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2014-12-16
函数说明：	过流事件的建立和返回
参数说明：	set_clr: 1 建立，0 返回
            soe_no: 事件组的起始序号
            i_set: 当前过流保护的定值
返回值：  	无
修改记录：
*/
int gl_soe_set_clr(u8 set_clr, int sw, u16 soe_no, u32 i_set, bool bfault)
{
    int ui_begin;
    ui_begin = UI_SW_INDEX_BEGIN(sw);
    switch (set_clr)
    {
    case 1:
    {
        DWORD Ia, Ib, Ic;
        Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
        Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
        Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
        if (soe_check(soe_no) == false)
        {
            soe_record_ev(soe_no, 1, Ia, Ib, Ic);
            if (bfault)
                rcd_start(sw, RECORD_TYPE_GLGZ, RECORD_LEN_TZQD); // 录波类型：跳闸类
        }
        pro_check_gl_abc(sw, i_set, Ia, Ib, Ic);              // 分相故障判断
        pro_check_fd_gl_abc(sw, i_set, Ia, Ib, Ic, soe_no);   // 分段分相故障判断
        if (soe_check(EV_GL_FAULT + sw * EV_SW_NUM) == false) // 过流总
        {
            soe_record_ev(EV_GL_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
        if (soe_check(EV_ALL_FAULT + sw * EV_SW_NUM) == false) // 保护总
        {
            soe_record_ev(EV_ALL_FAULT + sw * EV_SW_NUM, 1, 0, 0, 0);
        }
    }
    break;

    case 0:
    {
        if (soe_check(soe_no) == true)
        {
            soe_record_ev(soe_no, 0, 0, 0, 0);
        }
        if (pro_check_gl_all(sw) == false)
        {
            pro_rst_event(sw, EV_IABC_GL);
            pro_rst_event(sw, EV_IAB_GL);
            pro_rst_event(sw, EV_IBC_GL);
            pro_rst_event(sw, EV_ICA_GL);
            pro_rst_event(sw, EV_IA_GL);
            pro_rst_event(sw, EV_IB_GL);
            pro_rst_event(sw, EV_IC_GL);
            pro_rst_event(sw, EV_GL_FAULT);  // 过流总
            pro_rst_fd_gl_event(sw, soe_no); // 分段分相故障返回
        }
        if (pro_check_fault_all(sw) == false)
        {
            pro_rst_event(sw, EV_ALL_FAULT); // 保护总
        }
    }
    break;
    }

    return 0;
}

/******************************************************************************
函数名称：	gz_soe_set_clr
函数版本：	01.01
创建作者：	xxxxxx
创建日期：	2014-12-16
函数说明：	过流事件的建立和返回
参数说明：	set_clr: 1 建立，0 返回
            soe_no: 事件组的起始序号
            i_set: 当前过流保护的定值
返回值：  	无
修改记录：
*/
int gz_soe_set_clr(u8 set_clr, int sw, u16 soe_no, u32 i_set)
{
    int ui_begin, i;
    DWORD Idz;
    ui_begin = UI_SW_INDEX_BEGIN(sw);
    switch (set_clr)
    {
    case 1:
    {
        if (soe_check(soe_no) == false)
        {
            DWORD Ia, Ib, Ic;
            Ia = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA].m2[0]), 256, g_ui[ui_begin + SW_AC_IA].m2_factor_k);
            Ib = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IB].m2[0]), 256, g_ui[ui_begin + SW_AC_IB].m2_factor_k);
            Ic = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IC].m2[0]), 256, g_ui[ui_begin + SW_AC_IC].m2_factor_k);
            soe_record_ev(soe_no, 1, Ia, Ib, Ic);
        }

        for (i = 0; i < 3; i++)
        {
            if (soe_check(soe_no + i + 1) == false)
            {
                if (g_ui[ui_begin + SW_AC_IA + i].m2[0] > i_set)
                {
                    Idz = _Mul_Div_U(sqrt_32fix(g_ui[ui_begin + SW_AC_IA + i].m2[0]), 256, g_ui[ui_begin + SW_AC_IA + i].m2_factor_k);
                    soe_record_ev(soe_no + i + 1, 1, Idz, 0, 0);
                }
            }
        }
    }
    break;

    case 0:
    {
        if (soe_check(soe_no) == true)
        {
            soe_record_ev(soe_no, 0, 0, 0, 0);
        }

        for (i = 0; i < 3; i++)
        {
            if (soe_check(soe_no + i + 1) == true)
            {
                soe_record_ev(soe_no + i + 1, 0, 0, 0, 0);
            }
        }
    }
    break;
    }

    return 0;
}

/**
 * @brief          计算二次谐波含量是否超过设定值
 * @param[in/out]  {int} sw 开关号
 * @param[in/out]  {int} index 电流索引
 * @param[in/out]  {DWORD} xBcoe 谐波占比%
 * @param[in/out]  {DWORD} bQD 使能计算
 * @return         true 二次谐波含量超过设定值
 * @return         false  二次谐波含量没有超过设定值
 * @retval         none
 * 
 * @warning        none
 * @note           none
 */
bool XBCalc(int sw, int index, DWORD xBcoe, bool bQD)
{
    if (bQD)
    {
        if (g_ui[UI_SW_INDEX(sw, index)].m2[1] > _MulFac_U(g_ui[UI_SW_INDEX(sw, index)].m2[0], xBcoe))
        {
            return (true);
        }
    }
    return (false);
}

/*------------------------------ 测试函数 -------------------------------------
一个实体文件必须带一个本模块的测试函数来进行单元测试，如果的确不方便在本模块中
进行单元测试，必须在此注明实际的测试位置（例如在哪个实体文件中使用哪个测试函数）.
*/

/*------------------------------ 文件结束 -------------------------------------
 */