prlimplgetdata.c

104规约linux

//******************************************************************
//
//       文件名称：PrlImplData.c
//       文件内容：104协议项--基本电量数据获取实现文件
//   结构定义规则：见文档《变量定义规范》
//         创建者：
//       创建时间：2007-8-1
//******************************************************************


//*************************头文件包含区*****************************
#include "DefPrl.h"
#include "DefDispData.h"
#include "ShareMemDebugOut.h"
#include "ShareMemOp.h"
//******************************************************************

//基本电量：电压曲线

int PrlGetCurveChartU(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{

    int i,j;
    struct CurveChartU_LCD *Data = (struct CurveChartU_LCD *)PrlFrame->UserData.Data;
    TLineParam *LineParam = (TLineParam *)Param2;
    TLineDataSecond * LineDataSecond = (TLineDataSecond *)Param1;
    strncpy(Data->Name, LineParam->LineDspSet.LineName, STR_LINE_NAME_LEN);

    if(LineParam->MonitorType.UConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }

    for(i=0;i<5;i++)
    {
        for(j=0;j<64;j++)
        {
            Data->APhaseU[i][j]=LineDataSecond->BaseVlt.InstVlt.AN[i*256+j*4];
            Data->BPhaseU[i][j]=LineDataSecond->BaseVlt.InstVlt.BN[i*256+j*4];
            Data->CPhaseU[i][j]=LineDataSecond->BaseVlt.InstVlt.CN[i*256+j*4];
        }
    }
    PrlFrame->UserData.DataLen = sizeof(struct CurveChartU_LCD);
    return PRL_EXECUTE_OK;
}

//基本电量：电流曲线
int PrlGetCurveChartI(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    
    int i,j;
    struct CurveChartI_LCD *Data = (struct CurveChartI_LCD *)PrlFrame->UserData.Data;
    TLineParam *LineParam = (TLineParam *)Param2;
    TLineDataSecond * LineDataSecond = (TLineDataSecond *)Param1;
    
    strncpy(Data->Name, LineParam->LineDspSet.LineName, STR_LINE_NAME_LEN);

    if(LineParam->MonitorType.IConnectionType == CT_V)
    {
        Data->LineFlag=1;
    }
    else
    {
        Data->LineFlag=0;
    }

    for(i=0;i<5;i++)
    {
        for(j=0;j<64;j++)
        {
            Data->APhaseI[i][j]=LineDataSecond->BaseCrrn.InstCrrn.AN[i*256+j*4];
            Data->BPhaseI[i][j]=LineDataSecond->BaseCrrn.InstCrrn.BN[i*256+j*4];
            Data->CPhaseI[i][j]=LineDataSecond->BaseCrrn.InstCrrn.CN[i*256+j*4];
        }
    }
    PrlFrame->UserData.DataLen = sizeof(struct CurveChartI_LCD);
    return PRL_EXECUTE_OK;
}


//基本电量：相量图
int PrlGetVertChart(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    unsigned int LineID=PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct VertChart_LCD *Data = (struct VertChart_LCD *)PrlFrame->UserData.Data;
    TLineParam *LineParam = (TLineParam *)Param2;
    TLineDataSecond * LineDataSecond = (TLineDataSecond *)Param1;
    strncpy(Data->Name, LineParam->LineDspSet.LineName,  STR_LINE_NAME_LEN);
    LineDataSecond = smGetLineDataSecond(LineID);

    Data->APhaseU=LineDataSecond->BaseVlt.FndmVltRms.AN;
    Data->BPhaseU=LineDataSecond->BaseVlt.FndmVltRms.BN;
    Data->CPhaseU=LineDataSecond->BaseVlt.FndmVltRms.CN;
    Data->APhaseI=LineDataSecond->BaseCrrn.FndmCrrnRms.AN;
    Data->BPhaseI=LineDataSecond->BaseCrrn.FndmCrrnRms.BN;
    Data->CPhaseI=LineDataSecond->BaseCrrn.FndmCrrnRms.CN;
    Data->APhsPsU=LineDataSecond->BaseVlt.FndmVltPhs.AN;
    Data->APhsPsI=LineDataSecond->BaseCrrn.FndmCrrnPhs.AN;
    Data->BPhsPsU=LineDataSecond->BaseVlt.FndmVltPhs.BN;
    Data->BPhsPsI=LineDataSecond->BaseCrrn.FndmCrrnPhs.BN;
    Data->CPhsPsU=LineDataSecond->BaseVlt.FndmVltPhs.CN;
    Data->CPhsPsI=LineDataSecond->BaseCrrn.FndmCrrnPhs.CN;
    
    PrlFrame->UserData.DataLen = sizeof(struct VertChart_LCD);
    return PRL_EXECUTE_OK;
}

//基本电量:电压有效值
int PrlGetUnEffctv(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct UnEffctv_LCD *Data = (struct UnEffctv_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->LnUnEffctv_A=LineDataSecond->BaseVlt.LnVltRms.AN;
        Data->LnUnEffctv_B=LineDataSecond->BaseVlt.LnVltRms.BN;
        Data->LnUnEffctv_C=LineDataSecond->BaseVlt.LnVltRms.CN;
        Data->PhsUnEffctv_A=LineDataSecond->BaseVlt.PhsVltRms.AN;
        Data->PhsUnEffctv_B=LineDataSecond->BaseVlt.PhsVltRms.BN;
        Data->PhsUnEffctv_C=LineDataSecond->BaseVlt.PhsVltRms.CN;

        Data->FunPhsUnEffctv_A=LineDataSecond->BaseVlt.FndmVltRms.AN;
        Data->FunPhsUnPhs_A=LineDataSecond->BaseVlt.FndmVltPhs.AN;
        Data->FunPhsUnEffctv_B=LineDataSecond->BaseVlt.FndmVltRms.BN;
        Data->FunPhsUnPhs_B=LineDataSecond->BaseVlt.FndmVltPhs.BN;
        Data->FunPhsUnEffctv_C=LineDataSecond->BaseVlt.FndmVltRms.CN;
        Data->FunPhsUnPhs_C=LineDataSecond->BaseVlt.FndmVltPhs.CN;

        Data->FunLnUnEffctv_A=LineDataSecond->BaseVlt.FndmVltRms.AN;
        Data->FunLnUnPhs_A=LineDataSecond->BaseVlt.FndmVltPhs.AN;
        Data->FunLnUnEffctv_B=LineDataSecond->BaseVlt.FndmVltRms.BN;
        Data->FunLnUnPhs_B=LineDataSecond->BaseVlt.FndmVltPhs.BN;
        Data->FunLnUnEffctv_C=LineDataSecond->BaseVlt.FndmVltRms.CN;
        Data->FunLnUnPhs_C=LineDataSecond->BaseVlt.FndmVltPhs.CN;
    }
    else if(Data->MntrReal==SHOW_MR_IN_MINUTE)
    {
        TLineDataMinute * LineDataMinute = (TLineDataMinute *)Param1;
        Data->LnUnEffctv_A=LineDataMinute->AvgVlt.LnVltRms.AN;
        Data->LnUnEffctv_B=LineDataMinute->AvgVlt.LnVltRms.BN;
        Data->LnUnEffctv_C=LineDataMinute->AvgVlt.LnVltRms.CN;
        Data->PhsUnEffctv_A=LineDataMinute->AvgVlt.PhsVltRms.AN;
        Data->PhsUnEffctv_B=LineDataMinute->AvgVlt.PhsVltRms.BN;
        Data->PhsUnEffctv_C=LineDataMinute->AvgVlt.PhsVltRms.CN;

        Data->FunPhsUnEffctv_A=LineDataMinute->AvgVlt.FndmVltRms.AN;
        Data->FunPhsUnPhs_A=LineDataMinute->AvgVlt.FndmVltPhs.AN;
        Data->FunPhsUnEffctv_B=LineDataMinute->AvgVlt.FndmVltRms.BN;
        Data->FunPhsUnPhs_B=LineDataMinute->AvgVlt.FndmVltPhs.BN;
        Data->FunPhsUnEffctv_C=LineDataMinute->AvgVlt.FndmVltRms.CN;
        Data->FunPhsUnPhs_C=LineDataMinute->AvgVlt.FndmVltPhs.CN;
        Data->FunLnUnEffctv_A=LineDataMinute->AvgVlt.FndmVltRms.AN;
        Data->FunLnUnPhs_A=LineDataMinute->AvgVlt.FndmVltPhs.AN;
        Data->FunLnUnEffctv_B=LineDataMinute->AvgVlt.FndmVltRms.BN;
        Data->FunLnUnPhs_B=LineDataMinute->AvgVlt.FndmVltPhs.BN;
        Data->FunLnUnEffctv_C=LineDataMinute->AvgVlt.FndmVltRms.CN;
        Data->FunLnUnPhs_C=LineDataMinute->AvgVlt.FndmVltPhs.CN;
    }
    PrlFrame->UserData.DataLen = sizeof(struct UnEffctv_LCD);
    return PRL_EXECUTE_OK;
}

//基本变量:电流有效值
int PrlGetInEffctv(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct InEffctv_LCD *Data = (struct InEffctv_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(Data->MntrReal==SHOW_MR_IN_SECOND)
    {
        TLineDataSecond * LineDataSecond = (TLineDataSecond *)Param1;
        Data->LnInEffctv_A=LineDataSecond->BaseCrrn.LnCrrnRms.AN;
        Data->LnInEffctv_B=LineDataSecond->BaseCrrn.LnCrrnRms.BN;
        Data->LnInEffctv_C=LineDataSecond->BaseCrrn.LnCrrnRms.CN;
        Data->PhsInEffctv_A=LineDataSecond->BaseCrrn.PhsCrrnRms.AN;
        Data->PhsInEffctv_B=LineDataSecond->BaseCrrn.PhsCrrnRms.BN;
        Data->PhsInEffctv_C=LineDataSecond->BaseCrrn.PhsCrrnRms.CN;

        Data->FunPhsInEffctv_A=LineDataSecond->BaseCrrn.FndmCrrnRms.AN;
        Data->FunPhsInPhs_A=LineDataSecond->BaseCrrn.FndmCrrnPhs.AN;
        Data->FunPhsInEffctv_B=LineDataSecond->BaseCrrn.FndmCrrnRms.BN;
        Data->FunPhsInPhs_B=LineDataSecond->BaseCrrn.FndmCrrnPhs.BN;
        Data->FunPhsInEffctv_C=LineDataSecond->BaseCrrn.FndmCrrnRms.CN;
        Data->FunPhsInPhs_C=LineDataSecond->BaseCrrn.FndmCrrnPhs.CN;

        Data->FunLnInEffctv_A=LineDataSecond->BaseCrrn.FndmCrrnRms.AN;
        Data->FunLnInPhs_A=LineDataSecond->BaseCrrn.FndmCrrnPhs.AN;
        Data->FunLnInEffctv_B=LineDataSecond->BaseCrrn.FndmCrrnRms.BN;
        Data->FunLnInPhs_B=LineDataSecond->BaseCrrn.FndmCrrnPhs.BN;
        Data->FunLnInEffctv_C=LineDataSecond->BaseCrrn.FndmCrrnRms.CN;
        Data->FunLnInPhs_C=LineDataSecond->BaseCrrn.FndmCrrnPhs.CN;
    }
    else if(Data->MntrReal==SHOW_MR_IN_MINUTE)
    {
        TLineDataMinute * LineDataMinute = (TLineDataMinute *)Param1;
        Data->LnInEffctv_A=LineDataMinute->AvgCrrn.LnCrrnRms.AN;
        Data->LnInEffctv_B=LineDataMinute->AvgCrrn.LnCrrnRms.BN;
        Data->LnInEffctv_C=LineDataMinute->AvgCrrn.LnCrrnRms.CN;
        Data->PhsInEffctv_A=LineDataMinute->AvgCrrn.PhsCrrnRms.AN;
        Data->PhsInEffctv_B=LineDataMinute->AvgCrrn.PhsCrrnRms.BN;
        Data->PhsInEffctv_C=LineDataMinute->AvgCrrn.PhsCrrnRms.CN;

        Data->FunPhsInEffctv_A=LineDataMinute->AvgCrrn.FndmCrrnRms.AN;
        Data->FunPhsInPhs_A=LineDataMinute->AvgCrrn.FndmCrrnPhs.AN;
        Data->FunPhsInEffctv_B=LineDataMinute->AvgCrrn.FndmCrrnRms.BN;
        Data->FunPhsInPhs_B=LineDataMinute->AvgCrrn.FndmCrrnPhs.BN;
        Data->FunPhsInEffctv_C=LineDataMinute->AvgCrrn.FndmCrrnRms.CN;
        Data->FunPhsInPhs_C=LineDataMinute->AvgCrrn.FndmCrrnPhs.CN;

        Data->FunLnInEffctv_A=LineDataMinute->AvgCrrn.FndmCrrnRms.AN;
        Data->FunLnInPhs_A=LineDataMinute->AvgCrrn.FndmCrrnPhs.AN;
        Data->FunLnInEffctv_B=LineDataMinute->AvgCrrn.FndmCrrnRms.BN;
        Data->FunLnInPhs_B=LineDataMinute->AvgCrrn.FndmCrrnPhs.BN;
        Data->FunLnInEffctv_C=LineDataMinute->AvgCrrn.FndmCrrnRms.CN;
        Data->FunLnInPhs_C=LineDataMinute->AvgCrrn.FndmCrrnPhs.CN;
    }
    PrlFrame->UserData.DataLen = sizeof(struct InEffctv_LCD);
    return PRL_EXECUTE_OK;
}

int PrlGetPn(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct Pn_LCD *Data = (struct Pn_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->Pn_A=LineDataSecond->BasePw.Pn.AN;
        Data->Pn_B=LineDataSecond->BasePw.Pn.BN;
        Data->Pn_C=LineDataSecond->BasePw.Pn.CN;
        Data->Pn_3=LineDataSecond->BasePw.Pn.All;
        Data->FunPn_A=LineDataSecond->BasePw.FndmPn.AN;
        Data->FunPn_B=LineDataSecond->BasePw.FndmPn.BN;
        Data->FunPn_C=LineDataSecond->BasePw.FndmPn.CN;
        Data->FunPn_3=LineDataSecond->BasePw.FndmPn.All;
    }
    else if(Data->MntrReal==SHOW_MR_IN_MINUTE)
    {
        TLineDataMinute * LineDataMinute = (TLineDataMinute *)Param1;
        Data->Pn_A=LineDataMinute->AvgPw.Pn.AN;
        Data->Pn_B=LineDataMinute->AvgPw.Pn.BN;
        Data->Pn_C=LineDataMinute->AvgPw.Pn.CN;
        Data->Pn_3=LineDataMinute->AvgPw.Pn.All;
        Data->FunPn_A=LineDataMinute->AvgPw.FndmPn.AN;
        Data->FunPn_B=LineDataMinute->AvgPw.FndmPn.BN;
        Data->FunPn_C=LineDataMinute->AvgPw.FndmPn.CN;
        Data->FunPn_3=LineDataMinute->AvgPw.FndmPn.All;
    }
    PrlFrame->UserData.DataLen = sizeof(struct Pn_LCD);
    return PRL_EXECUTE_OK;
}

int PrlGetQn(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct Qn_LCD *Data = (struct Qn_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->Qn_A=LineDataSecond->BasePw.Qn.AN;
        Data->Qn_B=LineDataSecond->BasePw.Qn.BN;
        Data->Qn_C=LineDataSecond->BasePw.Qn.CN;
        Data->Qn_3=LineDataSecond->BasePw.Qn.All;
        Data->QnPhs_A=(int)LineDataSecond->BasePw.QnPhs.AN;
        Data->QnPhs_B=(int)LineDataSecond->BasePw.QnPhs.BN;
        Data->QnPhs_C=(int)LineDataSecond->BasePw.QnPhs.CN;
        Data->QnPhs_3=(int)LineDataSecond->BasePw.QnPhs.All;
        Data->FunQn_A=LineDataSecond->BasePw.FndmQn.AN;
        Data->FunQn_B=LineDataSecond->BasePw.FndmQn.BN;
        Data->FunQn_C=LineDataSecond->BasePw.FndmQn.CN;
        Data->FunQn_3=LineDataSecond->BasePw.FndmQn.All;
        Data->FunQnPhs_A=(int)LineDataSecond->BasePw.FndmQnPhs.AN;
        Data->FunQnPhs_B=(int)LineDataSecond->BasePw.FndmQnPhs.BN;
        Data->FunQnPhs_C=(int)LineDataSecond->BasePw.FndmQnPhs.BN;
        Data->FunQnPhs_3=(int)LineDataSecond->BasePw.FndmQnPhs.All;
    }
    else if(Data->MntrReal==SHOW_MR_IN_MINUTE)
    {
        TLineDataMinute * LineDataMinute = (TLineDataMinute *)Param1;
        Data->Qn_A=LineDataMinute->AvgPw.Qn.AN;
        Data->Qn_B=LineDataMinute->AvgPw.Qn.BN;
        Data->Qn_C=LineDataMinute->AvgPw.Qn.CN;
        Data->Qn_3=LineDataMinute->AvgPw.Qn.All;
        Data->QnPhs_A=(int)LineDataMinute->AvgPw.QnPhs.AN;
        Data->QnPhs_B=(int)LineDataMinute->AvgPw.QnPhs.BN;
        Data->QnPhs_C=(int)LineDataMinute->AvgPw.QnPhs.CN;
        Data->QnPhs_3=(int)LineDataMinute->AvgPw.QnPhs.All;
        Data->FunQn_A=LineDataMinute->AvgPw.FndmQn.AN;
        Data->FunQn_B=LineDataMinute->AvgPw.FndmQn.BN;
        Data->FunQn_C=LineDataMinute->AvgPw.FndmQn.CN;
        Data->FunQn_3=LineDataMinute->AvgPw.FndmQn.All;
        Data->FunQnPhs_A=(int)LineDataMinute->AvgPw.FndmQnPhs.AN;
        Data->FunQnPhs_B=(int)LineDataMinute->AvgPw.FndmQnPhs.BN;
        Data->FunQnPhs_C=(int)LineDataMinute->AvgPw.FndmQnPhs.BN;
        Data->FunQnPhs_3=(int)LineDataMinute->AvgPw.FndmQnPhs.All;
    }
    PrlFrame->UserData.DataLen = sizeof(struct Qn_LCD);
    return PRL_EXECUTE_OK;
}

int PrlGetSn(TPrlFrame *PrlFrame, void *Param1, void *Param2)     
{
    TLineParam LineParam;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID + 1;
    struct Sn_LCD *Data = (struct Sn_LCD *)PrlFrame->UserData.Data;
    GetMainLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);