prlimplgethisdata.c

104规约linux

        Data->MxTtlHarInEffctv_C=0;
        memset(&Data->MxTtlHarInEffctv_C_T, 0, sizeof(Time_s));

        Data->MnTtlHarInEffctv_A=0;
        memset(&Data->MnTtlHarInEffctv_A_T, 0, sizeof(Time_s));
        Data->MnTtlHarInEffctv_B=0;
        memset(&Data->MnTtlHarInEffctv_B_T, 0, sizeof(Time_s));
        Data->MnTtlHarInEffctv_C=0;
        memset(&Data->MnTtlHarInEffctv_C_T, 0, sizeof(Time_s));
        
        Data->AvTtlInDstrtnRt_A=0;
        Data->MxTtlInDstrtnRt_A=0;
        Data->MnTtlInDstrtnRt_A=0;
        Data->AvTtlInDstrtnRt_B=0;
        Data->MxTtlInDstrtnRt_B=0;
        Data->MnTtlInDstrtnRt_B=0;
        Data->AvTtlInDstrtnRt_C=0;
        Data->MxTtlInDstrtnRt_C=0;
        Data->MnTtlInDstrtnRt_C=0;
        Data->TtlInDstrtnRt_A=0;
        Data->TtlInDstrtnRt_B=0;
        Data->TtlInDstrtnRt_C=0;
    }
    PrlFrame->UserData.DataLen = sizeof(struct TtlHarIn_LCD);
    return PRL_EXECUTE_OK;
}

//波动与闪变
int PrlGetUnFlcttnUnFlckr(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    TLineParam LineParam;
    TLineDataStatis *LineDataStatis = (TLineDataStatis *)Param1;
    struct UnFlcttnUnFlckr_LCD *Data = (struct UnFlcttnUnFlckr_LCD *)PrlFrame->UserData.Data;
    TimeYS curtime;
    TLineDataSecond *LineDataSecond = smGetLineDataSecond(LineID);
    Data->Stat = (unsigned int)Param2;
    GetMainLineParam(LineID, &LineParam);
    GetTimeYS(&curtime);

    strncpy(Data->Name, LineParam.LineDspSet.LineName, STR_LINE_NAME_LEN);

    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    
    //电压波动
    if(Data->Stat == SHOW_STAT_MINUTES)
    {
    //实时值
        Data->UnFlcttn_A=LineDataSecond->BaseVlt.VltFlct.AN;
        Data->UnFlcttn_B=LineDataSecond->BaseVlt.VltFlct.BN;
        Data->UnFlcttn_C=LineDataSecond->BaseVlt.VltFlct.CN;
    }
    else
    {
        //小时以上统计值

        //波动平均值
        Data->UnFlcttn_A=LineDataStatis->AvgVlt.VltFlct.AN;
        Data->UnFlcttn_B=LineDataStatis->AvgVlt.VltFlct.BN;
        Data->UnFlcttn_C=LineDataStatis->AvgVlt.VltFlct.CN;

        //波动极值
        Data->MxUnFlcttn_A=LineDataStatis->ExtrVltRes.VltFlctExtr.MxAN;
        FILL_TIME(Data->MxUnFlcttn_A_T,LineDataStatis->ExtrVltRes.VltFlctExtr.MxTmAN);
        Data->MnUnFlcttn_A=LineDataStatis->ExtrVltRes.VltFlctExtr.MnAN;
        FILL_TIME(Data->MnUnFlcttn_A_T,LineDataStatis->ExtrVltRes.VltFlctExtr.MnTmAN);
        
        Data->MxUnFlcttn_B=LineDataStatis->ExtrVltRes.VltFlctExtr.MxBN;
        FILL_TIME(Data->MxUnFlcttn_B_T,LineDataStatis->ExtrVltRes.VltFlctExtr.MxTmBN);
        Data->MnUnFlcttn_B=LineDataStatis->ExtrVltRes.VltFlctExtr.MnBN;
        FILL_TIME(Data->MnUnFlcttn_B_T,LineDataStatis->ExtrVltRes.VltFlctExtr.MnTmBN);
        
        Data->MxUnFlcttn_C=LineDataStatis->ExtrVltRes.VltFlctExtr.MxCN;
        FILL_TIME(Data->MxUnFlcttn_C_T,LineDataStatis->ExtrVltRes.VltFlctExtr.MxTmCN);
        Data->MnUnFlcttn_C=LineDataStatis->ExtrVltRes.VltFlctExtr.MnCN;
        FILL_TIME(Data->MnUnFlcttn_C_T,LineDataStatis->ExtrVltRes.VltFlctExtr.MnTmCN);

        //波动合格率
        Data->UnFlcttnQlfctnRt_A=LineDataStatis->QlfcRtVlt.VltFlctQlfcRt.QtAN;
        Data->UnFlcttnQlfctnRt_B=LineDataStatis->QlfcRtVlt.VltFlctQlfcRt.QtBN;
        Data->UnFlcttnQlfctnRt_C=LineDataStatis->QlfcRtVlt.VltFlctQlfcRt.QtCN;
    }
        

    //短时闪变
    if(Data->Stat == SHOW_STAT_MINUTES)
    {
        //实时值

        Data->ShrtTmUnFlckr_A=LineDataSecond->BaseVlt.ShrtTmVltFlck.AN;
        Data->ShrtTmUnFlckr_B=LineDataSecond->BaseVlt.ShrtTmVltFlck.BN;
        Data->ShrtTmUnFlckr_C=LineDataSecond->BaseVlt.ShrtTmVltFlck.CN;
    }
    else
    {
        //小时以上统计值

        //短时闪变平均值
        Data->ShrtTmUnFlckr_A=LineDataStatis->AvgVlt.ShrtTmVltFlck.AN;
        Data->ShrtTmUnFlckr_B=LineDataStatis->AvgVlt.ShrtTmVltFlck.BN;
        Data->ShrtTmUnFlckr_C=LineDataStatis->AvgVlt.ShrtTmVltFlck.CN;

        //短时闪变极值
        Data->MxShrtTmUnFlckr_A=LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MxAN;
        FILL_TIME(Data->MxShrtTmUnFlckr_A_T,LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MxTmAN);
        Data->MnShrtTmUnFlckr_A=LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MnAN;
        FILL_TIME(Data->MnShrtTmUnFlckr_A_T,LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MnTmAN);

        Data->MxShrtTmUnFlckr_B=LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MxBN;
        FILL_TIME(Data->MxShrtTmUnFlckr_B_T,LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MxTmBN);
        Data->MnShrtTmUnFlckr_B=LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MnBN;
        FILL_TIME(Data->MnShrtTmUnFlckr_B_T,LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MnTmBN);

        Data->MxShrtTmUnFlckr_C=LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MxCN;
        FILL_TIME(Data->MxShrtTmUnFlckr_C_T,LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MxTmCN);
        Data->MnShrtTmUnFlckr_C=LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MnCN;
        FILL_TIME(Data->MnShrtTmUnFlckr_C_T,LineDataStatis->ExtrVltRes.ShrtTmVltFlckExtr.MnTmCN);

        //短时闪变合格率
        Data->ShrtTmUnFlckrQlfctnRt_A=LineDataStatis->QlfcRtVlt.ShrtTmVltFlckQlfcRt.QtAN;
        Data->ShrtTmUnFlckrQlfctnRt_B=LineDataStatis->QlfcRtVlt.ShrtTmVltFlckQlfcRt.QtBN;
        Data->ShrtTmUnFlckrQlfctnRt_C=LineDataStatis->QlfcRtVlt.ShrtTmVltFlckQlfcRt.QtCN;
    }

    //长时闪变
    if(Data->Stat == SHOW_STAT_MINUTES)
    {
        //实时值
        Data->LngTmUnFlckr_A=LineDataSecond->BaseVlt.LngTmVltFlck.AN;
        Data->LngTmUnFlckr_B=LineDataSecond->BaseVlt.LngTmVltFlck.BN;
        Data->LngTmUnFlckr_C=LineDataSecond->BaseVlt.LngTmVltFlck.CN;
    }
    else
    {
        //小时以上统计值

        //平均值
        Data->LngTmUnFlckr_A=LineDataStatis->AvgVlt.LngTmVltFlck.AN;
        Data->LngTmUnFlckr_B=LineDataStatis->AvgVlt.LngTmVltFlck.BN;
        Data->LngTmUnFlckr_C=LineDataStatis->AvgVlt.LngTmVltFlck.CN;

        //长时闪变极值
        Data->MxLngTmUnFlckr_A=LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MxAN;
        FILL_TIME(Data->MxLngTmUnFlckr_A_T,LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MxTmAN);
        Data->MnLngTmUnFlckr_A=LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MnAN;
        FILL_TIME(Data->MnLngTmUnFlckr_A_T,LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MnTmAN);

        Data->MxLngTmUnFlckr_B=LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MxBN;
        FILL_TIME(Data->MxLngTmUnFlckr_B_T,LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MxTmBN);
        Data->MnLngTmUnFlckr_B=LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MnBN;
        FILL_TIME(Data->MnLngTmUnFlckr_B_T,LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MnTmBN);

        Data->MxLngTmUnFlckr_C=LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MxCN;
        FILL_TIME(Data->MxLngTmUnFlckr_C_T,LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MxTmCN);
        Data->MnLngTmUnFlckr_C=LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MnCN;
        FILL_TIME(Data->MnLngTmUnFlckr_C_T,LineDataStatis->ExtrVltRes.LngTmVltFlckExtr.MnTmCN);

        //长时闪变合格率
        Data->LngTmUnFlckrQlfctnRt_A=LineDataStatis->QlfcRtVlt.LngTmVltFlckQlfcRt.QtAN;
        Data->LngTmUnFlckrQlfctnRt_B=LineDataStatis->QlfcRtVlt.LngTmVltFlckQlfcRt.QtBN;
        Data->LngTmUnFlckrQlfctnRt_C=LineDataStatis->QlfcRtVlt.LngTmVltFlckQlfcRt.QtCN;
    }

    if(CheckTimeMatch(Data->Stat, LineDataStatis->TimeStatis, curtime) == 0 && Data->Stat != 0)
    {
        //波动平均值
        Data->UnFlcttn_A=0;
        Data->UnFlcttn_B=0;
        Data->UnFlcttn_C=0;

        //波动极值
        Data->MxUnFlcttn_A=0;
        memset(&Data->MxUnFlcttn_A_T, 0, sizeof(Time_s));
        Data->MnUnFlcttn_A=0;
        memset(&Data->MnUnFlcttn_A_T, 0, sizeof(Time_s));
        
        Data->MxUnFlcttn_B=0;
        memset(&Data->MxUnFlcttn_B_T, 0, sizeof(Time_s));
        Data->MnUnFlcttn_B=0;
        memset(&Data->MnUnFlcttn_B_T, 0, sizeof(Time_s));
        
        Data->MxUnFlcttn_C=0;
        memset(&Data->MxUnFlcttn_C_T, 0, sizeof(Time_s));
        Data->MnUnFlcttn_C=0;
        memset(&Data->MnUnFlcttn_C_T, 0, sizeof(Time_s));

        //波动合格率
        Data->UnFlcttnQlfctnRt_A=0;
        Data->UnFlcttnQlfctnRt_B=0;
        Data->UnFlcttnQlfctnRt_C=0;

        //短时闪变平均值
        Data->ShrtTmUnFlckr_A=0;
        Data->ShrtTmUnFlckr_B=0;
        Data->ShrtTmUnFlckr_C=0;

        //短时闪变极值
        Data->MxShrtTmUnFlckr_A=0;
        memset(&Data->MxShrtTmUnFlckr_A_T, 0, sizeof(Time_s));
        Data->MnShrtTmUnFlckr_A=0;
        memset(&Data->MnShrtTmUnFlckr_A_T, 0, sizeof(Time_s));

        Data->MxShrtTmUnFlckr_B=0;
        memset(&Data->MxShrtTmUnFlckr_B_T, 0, sizeof(Time_s));
        Data->MnShrtTmUnFlckr_B=0;
        memset(&Data->MnShrtTmUnFlckr_B_T, 0, sizeof(Time_s));

        Data->MxShrtTmUnFlckr_C=0;
        memset(&Data->MxShrtTmUnFlckr_C_T, 0, sizeof(Time_s));
        Data->MnShrtTmUnFlckr_C=0;
        memset(&Data->MnShrtTmUnFlckr_C_T, 0, sizeof(Time_s));

        //短时闪变合格率
        Data->ShrtTmUnFlckrQlfctnRt_A=0;
        Data->ShrtTmUnFlckrQlfctnRt_B=0;
        Data->ShrtTmUnFlckrQlfctnRt_C=0;

        //长时闪变平均值
        Data->LngTmUnFlckr_A=0;
        Data->LngTmUnFlckr_B=0;
        Data->LngTmUnFlckr_C=0;

        //长时闪变极值
        Data->MxLngTmUnFlckr_A=0;
        memset(&Data->MxLngTmUnFlckr_A_T, 0, sizeof(Time_s));
        Data->MnLngTmUnFlckr_A=0;
        memset(&Data->MnLngTmUnFlckr_A_T, 0, sizeof(Time_s));

        Data->MxLngTmUnFlckr_B=0;
        memset(&Data->MxLngTmUnFlckr_B_T, 0, sizeof(Time_s));
        Data->MnLngTmUnFlckr_B=0;
        memset(&Data->MnLngTmUnFlckr_B_T, 0, sizeof(Time_s));

        Data->MxLngTmUnFlckr_C=0;
        memset(&Data->MxLngTmUnFlckr_C_T, 0, sizeof(Time_s));
        Data->MnLngTmUnFlckr_C=0;
        memset(&Data->MnLngTmUnFlckr_C_T, 0, sizeof(Time_s));

        //长时闪变合格率
        Data->LngTmUnFlckrQlfctnRt_A=0;
        Data->LngTmUnFlckrQlfctnRt_B=0;
        Data->LngTmUnFlckrQlfctnRt_C=0;
    }
    PrlFrame->UserData.DataLen = sizeof(struct UnFlcttnUnFlckr_LCD);
    return PRL_EXECUTE_OK;

}

//三相电压不平衡度
int PrlGetTrUnUnblnc(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    TLineParam LineParam;
    TLineDataStatis *LineDataStatis = (TLineDataStatis *)Param1;
    struct TrUnUnblnc_LCD *Data = (struct TrUnUnblnc_LCD *)PrlFrame->UserData.Data;
    TimeYS curtime;
    Data->Stat = (unsigned int)Param2;
    GetMainLineParam(LineID, &LineParam);
    GetTimeYS(&curtime);

    strncpy(Data->Name, LineParam.LineDspSet.LineName, STR_LINE_NAME_LEN);

    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    
    //平均电压不平衡度
    Data->UnUnblncRt = LineDataStatis->AvgVlt.VltUnbl.Unbl;
    //极值
    Data->MxUnUnblncRt = LineDataStatis->ExtrVltRes.VltUnblExtr.UnblMx;
    FILL_TIME(Data->MxUnUnblncRt_T, LineDataStatis->ExtrVltRes.VltUnblExtr.UnblMxTm);
    Data->MnUnUnblncRt=LineDataStatis->ExtrVltRes.VltUnblExtr.UnblMn;
    FILL_TIME(Data->MnUnUnblncRt_T,LineDataStatis->ExtrVltRes.VltUnblExtr.UnblMnTm);
    //合格率
    Data->UnBlncRt=LineDataStatis->QlfcRtVlt.VltUnblRt.Qt;

    //负序平均值
    Data->NgtvSqncUnEffctv_A=LineDataStatis->AvgVlt.VltUnbl.Ngtv;
    Data->NgtvSqncUnEffctv_B=LineDataStatis->AvgVlt.VltUnbl.Ngtv;
    Data->NgtvSqncUnEffctv_C=LineDataStatis->AvgVlt.VltUnbl.Ngtv;
    //负序极值
    Data->MxNgtvSqncUnEffctv_A = LineDataStatis->ExtrVltRes.VltUnblExtr.NgtvMx;
    FILL_TIME(Data->MxNgtvSqncUnEffctv_A_T, LineDataStatis->ExtrVltRes.VltUnblExtr.NgtvMxTm);
    Data->MnNgtvSqncUnEffctv_A = LineDataStatis->ExtrVltRes.VltUnblExtr.NgtvMn;
    FILL_TIME(Data->MnNgtvSqncUnEffctv_A_T, LineDataStatis->ExtrVltRes.VltUnblExtr.NgtvMnTm);
    
    //零序平均值
    Data->ZrSqncUnEffctv_A=LineDataStatis->AvgVlt.VltUnbl.Zr;
    Data->ZrSqncUnEffctv_B=LineDataStatis->AvgVlt.VltUnbl.Zr;
    Data->ZrSqncUnEffctv_C=LineDataStatis->AvgVlt.VltUnbl.Zr;
    //零序极值
    Data->MxZrSqncUnEffctv_A = LineDataStatis->ExtrVltRes.VltUnblExtr.ZrMx;
    FILL_TIME(Data->MxZrSqncUnEffctv_A_T, LineDataStatis->ExtrVltRes.VltUnblExtr.ZrMxTm);
    Data->MnZrSqncUnEffctv_A = LineDataStatis->ExtrVltRes.VltUnblExtr.ZrMn;
    FILL_TIME(Data->MnZrSqncUnEffctv_A_T, LineDataStatis->ExtrVltRes.VltUnblExtr.ZrMnTm);

    //正序平均值
    Data->PstvSqncUnEffctv_A=LineDataStatis->AvgVlt.VltUnbl.Pstv;
    Data->PstvSqncUnEffctv_B=LineDataStatis->AvgVlt.VltUnbl.Pstv;
    Data->PstvSqncUnEffctv_C=LineDataStatis->AvgVlt.VltUnbl.Pstv;
    //正序极值
    Data->MxPstvSqncUnEffctv_A = LineDataStatis->ExtrVltRes.VltUnblExtr.PstvMx;;
    FILL_TIME(Data->MxPstvSqncUnEffctv_A_T, LineDataStatis->ExtrVltRes.VltUnblExtr.PstvMxTm);
    Data->MnPstvSqncUnEffctv_A = LineDataStatis->ExtrVltRes.VltUnblExtr.PstvMn;
    FILL_TIME(Data->MnPstvSqncUnEffctv_A_T, LineDataStatis->ExtrVltRes.VltUnblExtr.PstvMnTm);

    if(CheckTimeMatch(Data->Stat, LineDataStatis->TimeStatis, curtime) == 0)
    {
        //平均电压不平衡度
        Data->UnUnblncRt = 0;
        //极值
        Data->MxUnUnblncRt = 0;
        memset(&Data->MxUnUnblncRt_T, 0, sizeof(Time_s));
        Data->MnUnUnblncRt=0;
        memset(&Data->MnUnUnblncRt_T, 0, sizeof(Time_s));
        //合格率
        Data->UnBlncRt=0;

        //负序平均值
        Data->NgtvSqncUnEffctv_A=0;
        Data->NgtvSqncUnEffctv_B=0;
        Data->NgtvSqncUnEffctv_C=0;
        //负序极值
        Data->MxNgtvSqncUnEffctv_A = 0;
        memset(&Data->MxNgtvSqncUnEffctv_A_T, 0, sizeof(Time_s));
    
        //零序平均值
        Data->ZrSqncUnEffctv_A=0;
        Data->ZrSqncUnEffctv_B=0;