prlimplgetdata.c

104规约linux

    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    Data->MntrReal = (unsigned int)Param2;
    
    if(Data->MntrReal==SHOW_MR_IN_SECOND)
    {
        TLineDataSecond * LineDataSecond = (TLineDataSecond *)Param1;
        Data->Sn_A=LineDataSecond->BasePw.Sn.AN;
        Data->Sn_B=LineDataSecond->BasePw.Sn.BN;
        Data->Sn_C=LineDataSecond->BasePw.Sn.CN;
        Data->Sn_M=LineDataSecond->BasePw.Sn.Mth;
        Data->Sn_V=LineDataSecond->BasePw.Sn.Vct;
        Data->FunSn_A=LineDataSecond->BasePw.FndmSn.AN;
        Data->FunSn_B=LineDataSecond->BasePw.FndmSn.BN;
        Data->FunSn_C=LineDataSecond->BasePw.FndmSn.CN;
        Data->FunSn_V=LineDataSecond->BasePw.FndmSn.Vct;
        Data->FunSn_M=LineDataSecond->BasePw.FndmSn.Mth;
    }
    else if(Data->MntrReal==SHOW_MR_IN_MINUTE)
    {
        TLineDataMinute * LineDataMinute = (TLineDataMinute *)Param1;
        Data->Sn_A=LineDataMinute->AvgPw.Sn.AN;
        Data->Sn_B=LineDataMinute->AvgPw.Sn.BN;
        Data->Sn_C=LineDataMinute->AvgPw.Sn.CN;
        Data->Sn_M=LineDataMinute->AvgPw.Sn.Mth;
        Data->Sn_V=LineDataMinute->AvgPw.Sn.Vct;
        Data->FunSn_A=LineDataMinute->AvgPw.FndmSn.AN;
        Data->FunSn_B=LineDataMinute->AvgPw.FndmSn.BN;
        Data->FunSn_C=LineDataMinute->AvgPw.FndmSn.CN;
        Data->FunSn_V=LineDataMinute->AvgPw.FndmSn.Vct;
        Data->FunSn_M=LineDataMinute->AvgPw.FndmSn.Mth;
    }
    PrlFrame->UserData.DataLen = sizeof(struct Sn_LCD);
    return PRL_EXECUTE_OK;
}

int PrlGetPwrFctr(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct PwrFctr_LCD *Data = (struct PwrFctr_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);
    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    Data->MntrReal = (unsigned int)Param2;
    
    if(Data->MntrReal==SHOW_MR_IN_SECOND)
    {
        TLineDataSecond * LineDataSecond = (TLineDataSecond *)Param1;
        Data->PwrFctr_A=LineDataSecond->BasePw.Pfct.AN;
        Data->PwrFctr_B=LineDataSecond->BasePw.Pfct.BN;
        Data->PwrFctr_C=LineDataSecond->BasePw.Pfct.CN;
        Data->PwrFctr_M=LineDataSecond->BasePw.Pfct.Mth;
        Data->PwrFctr_V=LineDataSecond->BasePw.Pfct.Vct;
        Data->FunPwrFctr_A=LineDataSecond->BasePw.FndmPfct.AN;
        Data->FunPwrFctr_B=LineDataSecond->BasePw.FndmPfct.BN;
        Data->FunPwrFctr_C=LineDataSecond->BasePw.FndmPfct.CN;
        Data->FunPwrFctr_M=LineDataSecond->BasePw.FndmPfct.Mth;
        Data->FunPwrFctr_V=LineDataSecond->BasePw.FndmPfct.Vct;
    }
    else if(Data->MntrReal==SHOW_MR_IN_MINUTE)
    {
        TLineDataMinute * LineDataMinute = (TLineDataMinute *)Param1;
        Data->PwrFctr_A=LineDataMinute->AvgPw.Pfct.AN;
        Data->PwrFctr_B=LineDataMinute->AvgPw.Pfct.BN;
        Data->PwrFctr_C=LineDataMinute->AvgPw.Pfct.CN;
        Data->PwrFctr_M=LineDataMinute->AvgPw.Pfct.Mth;
        Data->PwrFctr_V=LineDataMinute->AvgPw.Pfct.Vct;
        Data->FunPwrFctr_A=LineDataMinute->AvgPw.FndmPfct.AN;
        Data->FunPwrFctr_B=LineDataMinute->AvgPw.FndmPfct.BN;
        Data->FunPwrFctr_C=LineDataMinute->AvgPw.FndmPfct.CN;
        Data->FunPwrFctr_M=LineDataMinute->AvgPw.FndmPfct.Mth;
        Data->FunPwrFctr_V=LineDataMinute->AvgPw.FndmPfct.Vct;
    }
    PrlFrame->UserData.DataLen = sizeof(struct PwrFctr_LCD);
    return PRL_EXECUTE_OK;
}

int PrlGetFrq(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct Frq_LCD *Data = (struct Frq_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);
    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    Data->MntrReal = (unsigned int)Param2;
    
    if(Data->MntrReal==SHOW_MR_IN_SECOND)
    {
        TLineDataSecond * LineDataSecond = (TLineDataSecond *)Param1;
        Data->AValue=LineDataSecond->BaseVlt.Frq.AN;
        Data->BValue=LineDataSecond->BaseVlt.Frq.BN;
        Data->CValue=LineDataSecond->BaseVlt.Frq.CN;
    }
    else if(Data->MntrReal==SHOW_MR_IN_MINUTE)
    {
        TLineDataMinute * LineDataMinute = (TLineDataMinute *)Param1;
        Data->AValue=LineDataMinute->AvgVlt.Frq.AN;
        Data->BValue=LineDataMinute->AvgVlt.Frq.BN;
        Data->CValue=LineDataMinute->AvgVlt.Frq.CN;
    }
    PrlFrame->UserData.DataLen = sizeof(struct Frq_LCD);
    return PRL_EXECUTE_OK;
}

//谐波相关表格数据本应该放入实时数据类别，但考虑到与老版MENU程序的兼容性，暂时
//仍然支持其在历史数据中查询
int PrlGetHarUIP(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct HarUIP_LCD *Data = (struct HarUIP_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);
    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_SECOND)
    {
        int i=0;
        TLineDataSecond *LineDataSecond = smGetLineDataSecond(LineID);
        Data->MntrReal=SHOW_MR_IN_SECOND;
	      for(i=0;i<HRMN_NUM -3;i++)
		    {
			      Data->AValue[i] = LineDataSecond->BasePw.HrmnVltCrrnPhsSub.AN[i];
	          Data->BValue[i] = LineDataSecond->BasePw.HrmnVltCrrnPhsSub.BN[i];
		        Data->CValue[i] = LineDataSecond->BasePw.HrmnVltCrrnPhsSub.CN[i];
        }
    }
    else 
    {
        return PRL_EXECUTE_FAILED;
    }
    PrlFrame->UserData.DataLen = sizeof(struct HarUIP_LCD);
    return PRL_EXECUTE_OK;
}


int PrlGetHstgrmUn(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct HstgrmUn_LCD *Data = (struct HstgrmUn_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);
    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_SECOND)
    {
        int i=0;
        TLineDataSecond *LineDataSecond = smGetLineDataSecond(LineID);
        Data->MntrReal=SHOW_MR_IN_SECOND;
        for( i=0;i<HRMN_NUM - 3;i++)
        {
            Data->APhaseUn[i] = LineDataSecond->BaseVlt.HrmnVltCnt.AN[i];
            Data->BPhaseUn[i] = LineDataSecond->BaseVlt.HrmnVltCnt.BN[i];
            Data->CPhaseUn[i] = LineDataSecond->BaseVlt.HrmnVltCnt.CN[i];
            Data->APhaseUnQlfctn[i] = LineDataSecond->BaseVlt.HrmnVltCntRt.AN[i];
            Data->BPhaseUnQlfctn[i] = LineDataSecond->BaseVlt.HrmnVltCntRt.BN[i];
            Data->CPhaseUnQlfctn[i] = LineDataSecond->BaseVlt.HrmnVltCntRt.CN[i];
        }
    }
    else if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_MINUTE)
    {
        int i = 0;
        TLineDataMinute *LineDataMinute = smGetLineDataMinute(LineID);
        Data->MntrReal=SHOW_MR_IN_MINUTE;
        for( i=0;i<HRMN_NUM - 3;i++)
        {
            Data->APhaseUn[i] = LineDataMinute->AvgVlt.HrmnVltCnt.AN[i];
            Data->BPhaseUn[i] = LineDataMinute->AvgVlt.HrmnVltCnt.BN[i];
            Data->CPhaseUn[i] = LineDataMinute->AvgVlt.HrmnVltCnt.CN[i];
            Data->APhaseUnQlfctn[i] = LineDataMinute->AvgVlt.HrmnVltCntRt.AN[i];
            Data->BPhaseUnQlfctn[i] = LineDataMinute->AvgVlt.HrmnVltCntRt.BN[i];
            Data->CPhaseUnQlfctn[i] = LineDataMinute->AvgVlt.HrmnVltCntRt.CN[i];
        }
    }
    else
    {
        return PRL_EXECUTE_FAILED;
    }
    PrlFrame->UserData.DataLen = sizeof(struct HstgrmUn_LCD);
    return PRL_EXECUTE_OK;
}

int PrlGetHstgrmIn(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct HstgrmIn_LCD *Data = (struct HstgrmIn_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);
    if(LineParam.MonitorType.IConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    Data->MntrReal = (unsigned int)Param2;
    
    if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_SECOND)
    {
        int i=0;
        TLineDataSecond *LineDataSecond = smGetLineDataSecond(LineID);
        Data->MntrReal=SHOW_MR_IN_SECOND;
        for( i=0;i<HRMN_NUM - 3;i++)
        {
            Data->APhaseIn[i] = LineDataSecond->BaseCrrn.HrmnCrrnCnt.AN[i];
            Data->BPhaseIn[i] = LineDataSecond->BaseCrrn.HrmnCrrnCnt.BN[i];
            Data->CPhaseIn[i] = LineDataSecond->BaseCrrn.HrmnCrrnCnt.CN[i];
            Data->APhaseInQlfctn[i] = LineDataSecond->BaseCrrn.HrmnCrrnCntRt.AN[i];
            Data->BPhaseInQlfctn[i] = LineDataSecond->BaseCrrn.HrmnCrrnCntRt.BN[i];
            Data->CPhaseInQlfctn[i] = LineDataSecond->BaseCrrn.HrmnCrrnCntRt.CN[i];
        }
    }
    else if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_MINUTE)
    {
        int i = 0;
        TLineDataMinute *LineDataMinute = smGetLineDataMinute(LineID);
        Data->MntrReal=SHOW_MR_IN_MINUTE;
        for( i=0;i<HRMN_NUM - 3;i++)
        {
            Data->APhaseIn[i] = LineDataMinute->AvgCrrn.HrmnCrrnCnt.AN[i];
            Data->BPhaseIn[i] = LineDataMinute->AvgCrrn.HrmnCrrnCnt.BN[i];
            Data->CPhaseIn[i] = LineDataMinute->AvgCrrn.HrmnCrrnCnt.CN[i];
            Data->APhaseInQlfctn[i] = LineDataMinute->AvgCrrn.HrmnCrrnCntRt.AN[i];
            Data->BPhaseInQlfctn[i] = LineDataMinute->AvgCrrn.HrmnCrrnCntRt.BN[i];
            Data->CPhaseInQlfctn[i] = LineDataMinute->AvgCrrn.HrmnCrrnCntRt.CN[i];
       }
    }
    PrlFrame->UserData.DataLen = sizeof(struct HstgrmIn_LCD);
    return PRL_EXECUTE_OK;
}
int PrlGetHarUnEnvlp(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct HarUnEnvlp_LCD *Data = (struct HarUnEnvlp_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);
    if(LineParam.MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    Data->MntrReal = (unsigned int)Param2;
    
    if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_SECOND)
    {
        int i=0;
        TLineDataSecond *LineDataSecond = smGetLineDataSecond(LineID);
        Data->MntrReal=SHOW_MR_IN_SECOND;
        for( i=0;i<IHRMN_NUM -1;i++)
        {
            Data->Frq[i] = (float)50/IHRMN_NUM_ONE_HRMN*i;
            Data->APhaseUn[i]=LineDataSecond->BaseVlt.IHrmnVltCnt.AN[i];
            Data->BPhaseUn[i]=LineDataSecond->BaseVlt.IHrmnVltCnt.BN[i];
            Data->CPhaseUn[i]=LineDataSecond->BaseVlt.IHrmnVltCnt.CN[i];
        }
    }
    else if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_MINUTE)
    {
        int i = 0;
        TLineDataMinute *LineDataMinute = smGetLineDataMinute(LineID);
        Data->MntrReal=SHOW_MR_IN_MINUTE;
        for(i=0;i<IHRMN_NUM;i++)
        {    
            Data->Frq[i] = (float)50/IHRMN_NUM_ONE_HRMN*i;
            Data->APhaseUn[i]=LineDataMinute->AvgVlt.IHrmnVltCnt.AN[i];
            Data->BPhaseUn[i]=LineDataMinute->AvgVlt.IHrmnVltCnt.BN[i];
            Data->CPhaseUn[i]=LineDataMinute->AvgVlt.IHrmnVltCnt.CN[i];
        }
    }
    PrlFrame->UserData.DataLen = sizeof(struct HarUnEnvlp_LCD);
    return PRL_EXECUTE_OK;
}

int PrlGetHarInEnvlp(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct HarInEnvlp_LCD *Data = (struct HarInEnvlp_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);
    if(LineParam.MonitorType.IConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }
    Data->MntrReal = (unsigned int)Param2;
    
    if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_SECOND)
    {
        int i=0;
        TLineDataSecond *LineDataSecond = smGetLineDataSecond(LineID);
        Data->MntrReal=SHOW_MR_IN_SECOND;
        for( i=0;i<IHRMN_NUM -1;i++)
        {
            Data->Frq[i] = (float)50/IHRMN_NUM_ONE_HRMN*i;
            Data->APhaseIn[i]=LineDataSecond->BaseCrrn.IHrmnCrrnCnt.AN[i];
            Data->BPhaseIn[i]=LineDataSecond->BaseCrrn.IHrmnCrrnCnt.BN[i];
            Data->CPhaseIn[i]=LineDataSecond->BaseCrrn.IHrmnCrrnCnt.CN[i];
        }
    }
    else if(PrlFrame->UserData.TransReason == TR_SEASON_FOR_MINUTE)
    {
        int i = 0;
        TLineDataMinute *LineDataMinute = smGetLineDataMinute(LineID);
        Data->MntrReal=SHOW_MR_IN_MINUTE;
        for(i=0;i<IHRMN_NUM;i++)
        {    
            Data->Frq[i] = (float)50/IHRMN_NUM_ONE_HRMN*i;
            Data->APhaseIn[i]=LineDataMinute->AvgCrrn.IHrmnCrrnCnt.AN[i];
            Data->BPhaseIn[i]=LineDataMinute->AvgCrrn.IHrmnCrrnCnt.BN[i];
            Data->CPhaseIn[i]=LineDataMinute->AvgCrrn.IHrmnCrrnCnt.CN[i];
        }
    }
    PrlFrame->UserData.DataLen = sizeof(struct HarInEnvlp_LCD);
    return PRL_EXECUTE_OK;
}