prlimplparam.c

104规约linux

//******************************************************************
//
//   结构定义文件：PrlImplParam.c
//       文件内容：104协议项--参数查询与设置实现文件
//   结构定义规则：见文档《变量定义规范》
//         创建者：
//       创建时间：2007-8-1
//******************************************************************

//*************************头文件包含区*****************************
#include <sys/time.h>
#include <time.h>
#include "DefPrl.h"
#include "DefDispData.h"
#include "ShareMemDebugOut.h"
//******************************************************************

int TestOnline(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TGlobalParam *GlobalParam = (TGlobalParam *)Param1;
    unsigned long *Data = (unsigned long*)PrlFrame->UserData.Data;
    *Data = GlobalParam->MonitorID;
    return PRL_EXECUTE_OK;
}

int GetLineDsp(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    TGlobalParam *GlobalParam = (TGlobalParam *)Param1;
    struct LnDSPSt_LCD *Data = (struct LnDSPSt_LCD *)PrlFrame->UserData.Data;
    int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    Data->LnNm = PrlFrame->UserData.DeviceAddress.ThreadID;
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }
    GetBackupLineParam(LineID, &LineParam);
    strncpy(Data->Name,LineParam.LineDspSet.LineName, STR_LINE_NAME_LEN);
    Data->DfltShtCpcty=LineParam.LineDspSet.DfltShrtCpct;
    Data->UnLevel=LineParam.LineDspSet.VltLvl;
    Data->DSP1=LineParam.LineDspSet.DSP1;
    Data->DSP2=LineParam.LineDspSet.DSP2;
    Data->port1 = LineParam.LineDspSet.Port1;
    Data->port2 = LineParam.LineDspSet.Port2;
    Data->LineType=LineParam.LineDspSet.Type;
    Data->TtlLnDSP.LnAmnt=GlobalParam->LineCount;
    Data->TtlLnDSP.DSPAmnt=GlobalParam->DSPCount;
    PrlFrame->UserData.DataLen = sizeof(struct LnDSPSt_LCD);
    return PRL_EXECUTE_OK;
}

int SetLineDsp(TPrlFrame *PrlFrame, void *Param, void *Param2)
{
    TLineParam LineParam;
    struct LnDSPSt_LCD *Data = (struct LnDSPSt_LCD *)PrlFrame->UserData.Data;
    int LineID = Data->LnNm + 1;
    int RetVal1,RetVal2;
    
    if (LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }
    GetBackupLineParam(LineID, &LineParam);
    strncpy(LineParam.LineDspSet.LineName, Data->Name, STR_LINE_NAME_LEN);
    LineParam.LineDspSet.VltLvl=Data->UnLevel;
    LineParam.LineDspSet.DfltShrtCpct=Data->DfltShtCpcty;
    LineParam.LineDspSet.Type=Data->LineType;
    LineParam.LineDspSet.DSP1=Data->DSP1;
    LineParam.LineDspSet.DSP2=Data->DSP2;
    LineParam.LineDspSet.Port1=Data->port1;
    LineParam.LineDspSet.Port2=Data->port2;
    SetBackupLineParam(LineID, &LineParam);
    SetGlobalParam(GPT_LN_COUNT, &Data->TtlLnDSP.LnAmnt);
    SetGlobalParam(GPT_DSP_COUNT, &Data->TtlLnDSP.DSPAmnt);

    RetVal1 = SaveLineParam();
    RetVal2 = SaveSysParam();
    if(RetVal1!=B_TRUE||RetVal2!=B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}

int GetPowerParam(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    struct PowerParam_LCD *Data =  (struct PowerParam_LCD *)PrlFrame->UserData.Data;
    int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    Data->LnNm = PrlFrame->UserData.DeviceAddress.ThreadID;
    //无效线路号
    DebugOutMsg(IX_M_NQS, 0, "LineID:%d", Data->LnNm);
    if(LineID > MAX_LINE_NUM)
    {
        if (Data->LnNm == 0xFF)
        {
            TLineParam CurLineParam;
            int LineIX = 0;
            for (LineIX=0; LineIX<MAX_LINE_NUM; LineIX++)
            {
                GetBackupLineParam(LineIX+1, &CurLineParam);
                strncpy(Data->Name, CurLineParam.LineDspSet.LineName, STR_LINE_NAME_LEN);
                Data->LnNm = LineID;
                Data->LineIn= CurLineParam.Rating.LnCrrn;
                Data->LnUn= CurLineParam.Rating.LnVlt;
                Data->PhsIn= CurLineParam.Rating.PhsCrrn;
                Data->PhsUn= CurLineParam.Rating.PhsVlt;
                Data->RtdFrq= CurLineParam.Rating.Frq;
                Data->RtdPwrFctr= CurLineParam.Rating.PFct;
                Data->TrphsPn= CurLineParam.Rating.TrphPn;
                Data->TrphsSn= CurLineParam.Rating.TrphSn;
                Data->UnphsPn= CurLineParam.Rating.UnphPn;
                Data->UnphsSn= CurLineParam.Rating.UnphSn;
                Data = (struct PowerParam_LCD *)((char *)Data+sizeof(struct PowerParam_LCD));
            }
            PrlFrame->UserData.DataLen = sizeof(struct PowerParam_LCD)*MAX_LINE_NUM;
            return PRL_EXECUTE_OK;
        }
        return PRL_INVALID_LINE_ID;
    }
    GetBackupLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName, STR_LINE_NAME_LEN);
    Data->LineIn= LineParam.Rating.LnCrrn;
    Data->LnUn= LineParam.Rating.LnVlt;
    Data->PhsIn= LineParam.Rating.PhsCrrn;
    Data->PhsUn= LineParam.Rating.PhsVlt;
    Data->RtdFrq= LineParam.Rating.Frq;
    Data->RtdPwrFctr= LineParam.Rating.PFct;
    Data->TrphsPn= LineParam.Rating.TrphPn;
    Data->TrphsSn= LineParam.Rating.TrphSn;
    Data->UnphsPn= LineParam.Rating.UnphPn;
    Data->UnphsSn= LineParam.Rating.UnphSn;
    PrlFrame->UserData.DataLen = sizeof(struct PowerParam_LCD);
    return PRL_EXECUTE_OK;
}
int SetPowerParam(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    struct PowerParam_LCD *Data =  (struct PowerParam_LCD *)PrlFrame->UserData.Data;
    int LineID = Data->LnNm+1;
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }
    GetBackupLineParam(LineID, &LineParam);
    DebugOutMsg(IX_M_NQS, 0, "LineID:%d LineName:%s", Data->LnNm, LineParam.LineDspSet.LineName);
    LineParam.Rating.LineID=LineID;
    LineParam.Rating.LnCrrn=Data->LineIn;
    LineParam.Rating.LnVlt=Data->LnUn ;
    LineParam.Rating.PhsCrrn=Data->PhsIn;
    LineParam.Rating.PhsVlt=Data->PhsUn;

    LineParam.Rating.Frq=Data->RtdFrq;
    LineParam.Rating.PFct=Data->RtdPwrFctr;
    LineParam.Rating.TrphPn=Data->TrphsPn;
    LineParam.Rating.TrphSn=Data->TrphsSn;
    LineParam.Rating.UnphPn=Data->UnphsPn;
    LineParam.Rating.UnphSn=Data->UnphsSn;

    SetBackupLineParam(LineID, &LineParam);

    if (SaveLineParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}

int GetPowerQuality(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    struct PowerQuality_LCD *Data = (struct PowerQuality_LCD *)PrlFrame->UserData.Data;
    int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    int Loop = 0;
    Data->LnNm = PrlFrame->UserData.DeviceAddress.ThreadID;
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }
    GetBackupLineParam(LineID, &LineParam);
    strncpy(Data->Name, LineParam.LineDspSet.LineName,  STR_LINE_NAME_LEN);

    Data->DfltShtCpcty=LineParam.LineDspSet.DfltShrtCpct;
    Data->FrqDvtn_Dwn= LineParam.UpDwn.FrqDvtnDwn;
    Data->FrqDvtn_Up= LineParam.UpDwn.FrqDvtnUp;
    Data->FrqVrtn_Dwn= LineParam.UpDwn.FrqVrtnDwn;
    Data->FrqVrtn_Up= LineParam.UpDwn.FrqVrtnUp;
    Data->In_Up= LineParam.UpDwn.CrrnUp;
    Data->LngTmUnFlckr_Up= LineParam.UpDwn.LngVltFlckUp;
    Data->LnUn_Dwn= LineParam.UpDwn.VltDvtnDwn;
    Data->LnUn_Up= LineParam.UpDwn.VltDvtnUp;
    Data->PhsUn_Dwn= LineParam.UpDwn.VltDvtnDwn;
    Data->PhsUn_Up= LineParam.UpDwn.VltDvtnUp;
    Data->ShrtTmUnFlckr_Up= LineParam.UpDwn.ShrtVltFlckUp;
    Data->ShtCpcty= LineParam.UpDwn.ShtCpct;
    Data->TrPhsPn_Dwn= LineParam.UpDwn.TrphPnDwn;
    Data->TrPhsPn_Up= LineParam.UpDwn.TrphPnUp;
    Data->TrPhsSn_Dwn= LineParam.UpDwn.TrphSnDwn;
    Data->TrPhsSn_Up= LineParam.UpDwn.TrphSnUp;
    Data->UnblcIn_Up= LineParam.UpDwn.CrrnUnblUp;
    Data->UnblcUn_Up= LineParam.UpDwn.VltUnblUp;
    Data->UnFlcttn_Dwn= LineParam.UpDwn.VltFlctDwn;
    Data->UnFlcttn_Up= LineParam.UpDwn.VltFlctUp;
    Data->UnLevel= LineParam.LineDspSet.VltLvl;
    Data->UnPhsPn_Dwn= LineParam.UpDwn.UnphPnDwn;
    Data->UnPhsPn_Up= LineParam.UpDwn.UnphPnUp;
    Data->UnPhsSn_Dwn= LineParam.UpDwn.UnphSnDwn;
    Data->UnPhsSn_Up= LineParam.UpDwn.UnphSnUp;
    Data->UnVrtn_Dwn= LineParam.UpDwn.VltVrtnDwn;
    Data->UnVrtn_Up= LineParam.UpDwn.VltVrtnUp;
    for(Loop=0; Loop<50; Loop++)
    {
        Data->harun.HRUn[Loop]= LineParam.HrmnPrpt.HrmnVlt[Loop+2];
        Data->harin.HRIn[Loop]=LineParam.HrmnPrpt.HrmnCrrn[Loop+2];
    }
    Data->harun.THDUn=LineParam.HrmnPrpt.TtlHrmnVltDstRt;
    Data->harun.ODDUn=LineParam.HrmnPrpt.OddVlt;
    Data->harun.EVNUn=LineParam.HrmnPrpt.EvnVlt;
    Data->harin.THDIn=LineParam.HrmnPrpt.TtlHrmnCrrnDstRt;
    PrlFrame->UserData.DataLen = sizeof(struct PowerQuality_LCD);
    return PRL_EXECUTE_OK;
}

int SetPowerQuality(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    struct PowerQuality_LCD *Data =  (struct PowerQuality_LCD *)PrlFrame->UserData.Data;
    int LineID = Data->LnNm+1;
    int Loop = 0;
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }
    GetBackupLineParam(LineID, &LineParam);
    LineParam.UpDwn.LineID=LineID;
    LineParam.LineDspSet.DfltShrtCpct = Data->DfltShtCpcty;
    LineParam.UpDwn.FrqDvtnDwn=Data->FrqDvtn_Dwn;
    LineParam.UpDwn.FrqDvtnUp=Data->FrqDvtn_Up;
    LineParam.UpDwn.FrqVrtnDwn=Data->FrqVrtn_Dwn;
    LineParam.UpDwn.FrqVrtnUp=Data->FrqVrtn_Up;
    LineParam.UpDwn.CrrnUp=Data->In_Up;
    LineParam.UpDwn.LngVltFlckUp = Data->LngTmUnFlckr_Up;
    LineParam.UpDwn.VltDvtnDwn=Data->PhsUn_Dwn;
    LineParam.UpDwn.VltDvtnUp=Data->PhsUn_Up;
    LineParam.UpDwn.ShrtVltFlckUp=Data->ShrtTmUnFlckr_Up;
    LineParam.UpDwn.ShtCpct=Data->ShtCpcty;
    LineParam.UpDwn.TrphPnDwn=Data->TrPhsPn_Dwn;
    LineParam.UpDwn.TrphPnUp=Data->TrPhsPn_Up;
    LineParam.UpDwn.TrphSnDwn=Data->TrPhsSn_Dwn;
    LineParam.UpDwn.TrphSnUp=Data->TrPhsSn_Up;
    LineParam.UpDwn.CrrnUnblUp=Data->UnblcIn_Up;
    LineParam.UpDwn.VltUnblUp=Data->UnblcUn_Up;
    LineParam.UpDwn.VltFlctDwn=Data->UnFlcttn_Dwn;
    LineParam.UpDwn.VltFlctUp=Data->UnFlcttn_Up;;
    LineParam.LineDspSet.VltLvl=Data->UnLevel;
    LineParam.UpDwn.UnphPnDwn=Data->UnPhsPn_Dwn;
    LineParam.UpDwn.UnphPnUp=Data->UnPhsPn_Up;
    LineParam.UpDwn.UnphSnDwn =Data->UnPhsSn_Dwn;
    LineParam.UpDwn.UnphSnUp=Data->UnPhsSn_Up;
    LineParam.UpDwn.VltVrtnDwn=Data->UnVrtn_Dwn;
    LineParam.UpDwn.VltVrtnUp=Data->UnVrtn_Up;
    for(Loop=0; Loop<50; Loop++)
    {
        LineParam.HrmnPrpt.HrmnVlt[Loop+2]=Data->harun.HRUn[Loop];
        LineParam.HrmnPrpt.HrmnCrrn[Loop+2]=Data->harin.HRIn[Loop];
    }
     
    LineParam.HrmnPrpt.TtlHrmnVltDstRt=Data->harun.THDUn;
    LineParam.HrmnPrpt.OddVlt=Data->harun.ODDUn;
    LineParam.HrmnPrpt.EvnVlt=Data->harun.EVNUn;
    LineParam.HrmnPrpt.TtlHrmnCrrnDstRt=Data->harin.THDIn;
    
    LineParam.HrmnPrpt.HrmnVlt[HRMN_NUM - 3]=Data->harun.ODDUn;
    LineParam.HrmnPrpt.HrmnVlt[HRMN_NUM - 2]=Data->harun.EVNUn;
    LineParam.HrmnPrpt.HrmnVlt[HRMN_NUM - 1]=Data->harun.THDUn;

    SetBackupLineParam(LineID, &LineParam);

    if (SaveLineParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}

int GetMonitorType(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{ 
    TLineParam LineParam;
    struct MonitorType_LCD *Data = (struct MonitorType_LCD *)PrlFrame->UserData.Data;
    int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    Data->LnNm = PrlFrame->UserData.DeviceAddress.ThreadID;
    
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }     
    GetBackupLineParam(LineID, &LineParam);     
    strncpy(Data->Name, LineParam.LineDspSet.LineName, STR_LINE_NAME_LEN);
    Data->UCnnctnTyp=LineParam.MonitorType.UConnectionType;
    Data->ICnnctnTyp=LineParam.MonitorType.IConnectionType;
    if (Data->UCnnctnTyp == CT_Y0)
    {
        Data->UCnnctnTyp = 1;
        Data->ICnnctnTyp = 1;
    }  
    PrlFrame->UserData.DataLen = sizeof(struct MonitorType_LCD);    
    return PRL_EXECUTE_OK;
}

int SetMonitorType(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    struct MonitorType_LCD *Data =  (struct MonitorType_LCD *)PrlFrame->UserData.Data;
    int LineID = Data->LnNm+1;
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }
    GetBackupLineParam(LineID, &LineParam);
    LineParam.MonitorType.LineID=LineID;
    if (Data->UCnnctnTyp == 1)
    {
        LineParam.MonitorType.UConnectionType = CT_Y0;
        LineParam.MonitorType.IConnectionType = CT_Y0;
    }
    else
    {
        LineParam.MonitorType.UConnectionType = CT_V;
        LineParam.MonitorType.IConnectionType = CT_V;
    }
    SetBackupLineParam(LineID, &LineParam);
    if (SaveLineParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}



int GetTransformer(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    struct Transformer_LCD *Data = (struct Transformer_LCD *)PrlFrame->UserData.Data;
    int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    Data->LnNm = PrlFrame->UserData.DeviceAddress.ThreadID;
    
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }   
    GetBackupLineParam(LineID, &LineParam);       
    strncpy(Data->Name, LineParam.LineDspSet.LineName, STR_LINE_NAME_LEN);