prlimplparam.c

104规约linux

    Data->UPrmry=LineParam.TransformerVlt.Primary;
    Data->UScndry=LineParam.TransformerVlt.Secondary;
    Data->IPrmry=LineParam.TransformerCrrn.Primary;
    Data->IScndry=LineParam.TransformerCrrn.Secondary;
    Data->UTransformerRt=LineParam.TransformerVlt.Rate;
    Data->ITransformerRt=LineParam.TransformerCrrn.Rate;
    Data->PrmryCnnctnTyp=LineParam.TransformerCrrn.ConnectionType;
    Data->ScndryCnnctnTyp=LineParam.TransformerVlt.ConnectionType; 
    PrlFrame->UserData.DataLen = sizeof(struct Transformer_LCD);
    return PRL_EXECUTE_OK;
}

int SetTransformer(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TLineParam LineParam;
    struct Transformer_LCD *Data =  (struct Transformer_LCD *)PrlFrame->UserData.Data;
    int LineID = Data->LnNm+1;
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }
    
    GetBackupLineParam(LineID, &LineParam);
    LineParam.TransformerVlt.LineID=LineID;
    LineParam.TransformerVlt.Primary=Data->UPrmry;
    LineParam.TransformerVlt.Secondary=Data->UScndry;
    LineParam.TransformerVlt.Rate=Data->UTransformerRt;
    LineParam.TransformerVlt.ConnectionType = Data->ScndryCnnctnTyp;
    LineParam.TransformerCrrn.LineID=LineID;
    LineParam.TransformerCrrn.Primary=Data->IPrmry;
    LineParam.TransformerCrrn.Secondary=Data->IScndry;
    LineParam.TransformerCrrn.Rate=Data->ITransformerRt;
    LineParam.TransformerCrrn.ConnectionType = Data->PrmryCnnctnTyp;
    SetBackupLineParam(LineID, &LineParam);
    if (SaveLineParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}

int GetDatetime(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TimeYS TimeNow;
    struct TimeDate_LCD *Data = (struct TimeDate_LCD *)PrlFrame->UserData.Data;
    GetTimeYS(&TimeNow);
    Data->Year=TimeNow.Year;
    Data->Month=TimeNow.Month;
    Data->Day=TimeNow.Day;
    Data->Hour=TimeNow.Hour;
    Data->Minute=TimeNow.Minute;
    Data->Second=TimeNow.Second;
    PrlFrame->UserData.DataLen = sizeof(struct TimeDate_LCD);
    return PRL_EXECUTE_OK;
}
#define PC
     
BSTATUS interSetDatetime(TimeYS TimeNew)
{
    struct tm TM;
    struct timeval valTemp;
    struct timezone zoneTemp;
    time_t temp;

    if(TimeNew.Year < 1970 || TimeNew.Year > 2037)
  	{
  	    return B_FALSE;
  	}
#ifdef PC  
    TM.tm_year=TimeNew.Year-1900;//从1900年开始计数
#else
    TM.tm_year=TimeNew.Year-1970;//从1970年开始计数,ARM_linux适合
#endif
    TM.tm_mon=TimeNew.Month-1;//范围0~11
    TM.tm_mday=TimeNew.Day;
    TM.tm_hour=TimeNew.Hour;
    TM.tm_min=TimeNew.Minute;
    TM.tm_sec=TimeNew.Second;
    temp=mktime(&TM);
    valTemp.tv_sec=(long)temp;
    valTemp.tv_usec=0;
    zoneTemp.tz_minuteswest=0;//暂时用格林尼治时区
    zoneTemp.tz_dsttime=0;
    if(settimeofday(&valTemp,&zoneTemp)==0)
    {  
        system("hwclock -w");
        return B_TRUE;
    }
    else
    {
        return B_FALSE;
    }
}

int SetDatetime(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TimeYS TimeNew;
    struct TimeDate_LCD *Data = (struct TimeDate_LCD *)PrlFrame->UserData.Data;
    BSTATUS RetVal;
    int WaitTime = 0;

    TimeNew.Year=Data->Year;
    TimeNew.Month=Data->Month;
    TimeNew.Day=Data->Day;
    TimeNew.Hour=Data->Hour;
    TimeNew.Minute=Data->Minute;
    TimeNew.Second=Data->Second;
    DebugOutMsg(IX_M_NQS, 0, "Modify Datetime to %4d-%2d-%2d %2d:%2d:%2d"
        , TimeNew.Year, TimeNew.Month, TimeNew.Day, TimeNew.Hour, TimeNew.Second);
    if(TimeNew.Year < 1970 || TimeNew.Year > 2037) return 0x0;
    SetmodifyTimeCtl(PS_REQUEST);
    while(1)
    {
        if(GetModifyTimeCtl() == PS_RESPONDOK)
        {
            RetVal = interSetDatetime(TimeNew);
            SetmodifyTimeCtl(PS_FINISH);
            if(RetVal == B_TRUE)
            {
                return PRL_EXECUTE_OK;
            }
            else
            {
                return PRL_EXECUTE_FAILED;
            }
        }
        usleep(100000);
        if((WaitTime++) > 30)
        {
            break;;
        }
    }
    return PRL_EXECUTE_FAILED;
}

int PrlGetSelfCheck(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    struct SelfCheck_LCD *Data = (struct SelfCheck_LCD *)PrlFrame->UserData.Data;
    unsigned int LineID = PrlFrame->UserData.DeviceAddress.ThreadID+1;
    unsigned int idx;
    TDeviceStatus buf;
    unsigned int loopnum, i;
    unsigned int dspmark;
    TLineParam MainLineParam;
    TGlobalParam MainGlobalParam;
    
    idx = PrlFrame->UserData.DeviceAddress.ThreadID;
    if(LineID > MAX_LINE_NUM)
    {
        return PRL_INVALID_LINE_ID;
    }    

    SetNeedCheckSpaceHD(OP_START);
    loopnum = 0;
    while(1)
    {
        if(GetNeedCheckSpaceHD() == OP_FINISH)
        {
            break;
        }
        loopnum ++;
        if(loopnum > 10)
        {
            break;
        }
    }

    GetMainGlobalParam(&MainGlobalParam);
    GetWholeDeviceStatus(&buf);
    for(i=0;i<MainGlobalParam.LineCount;i++)
    {
        GetMainLineParam(i+1, &MainLineParam);
        if(MainLineParam.LineDspSet.DSP1 == idx)
        {
            dspmark = DSPMARK_1;
        }
        else if(MainLineParam.LineDspSet.DSP2 == idx)
        {
            dspmark = DSPMARK_2;
        }
        else
        {
            continue;
        }
        Data->CodeSystem_DSP = (buf.LineStatus[i].IsInsOK[dspmark] == B_TRUE)? 1:0;
        Data->InterRAM_DSP=(buf.LineStatus[i].IsIRamOK[dspmark] == B_TRUE)? 1:0;
        Data->Timer_DSP=(buf.LineStatus[i].IsTimerOK[dspmark] == B_TRUE)? 1:0;
        Data->interrupt_DSP =(buf.LineStatus[i].IsIntOK[dspmark] == B_TRUE)?1:0;
        Data->Flash_DSP=(buf.LineStatus[i].IsFlashOK[dspmark] == B_TRUE)?1:0;
        Data->ExterRAM_DSP=(buf.LineStatus[i].IsORamOK[dspmark] == B_TRUE)?1:0;
        Data->ADCheck_DSP=(buf.LineStatus[i].IsADOK[dspmark]== B_TRUE)?1:0;
        if(dspmark == DSPMARK_2)
        {
            if(MainLineParam.LineDspSet.Port1 > 0)
            {
                Data->PTStatus_DSP[0]=(buf.LineStatus[i].IsPTAOK[DSPMARK_1]== B_TRUE)?1:0;
                Data->PTStatus_DSP[1]=(buf.LineStatus[i].IsPTBOK[DSPMARK_1]== B_TRUE)?1:0;
                Data->PTStatus_DSP[2]=(buf.LineStatus[i].IsPTCOK[DSPMARK_1]== B_TRUE)?1:0;
                Data->CTStatus_DSP[0]=(buf.LineStatus[i].IsCTAOK[DSPMARK_1]== B_TRUE)?1:0;
                Data->CTStatus_DSP[1]=(buf.LineStatus[i].IsCTBOK[DSPMARK_1]== B_TRUE)?1:0;
                Data->CTStatus_DSP[2]=(buf.LineStatus[i].IsCTCOK[DSPMARK_1]== B_TRUE)?1:0;
            }
            else if(buf.LineStatus[i].IsInsOK[dspmark] == B_TRUE && 
                buf.LineStatus[i].IsIRamOK[dspmark] == B_TRUE &&
                buf.LineStatus[i].IsTimerOK[dspmark] == B_TRUE &&
                buf.LineStatus[i].IsIntOK[dspmark] == B_TRUE &&
                buf.LineStatus[i].IsFlashOK[dspmark] == B_TRUE &&
                buf.LineStatus[i].IsORamOK[dspmark] == B_TRUE &&
                buf.LineStatus[i].IsADOK[dspmark]== B_TRUE)
            {
                Data->PTStatus_DSP[0]=1;
                Data->PTStatus_DSP[1]=1;
                Data->PTStatus_DSP[2]=1;
                Data->CTStatus_DSP[0]=1;
                Data->CTStatus_DSP[1]=1;
                Data->CTStatus_DSP[2]=1;
            }
            else
            {
                Data->PTStatus_DSP[0]=0;
                Data->PTStatus_DSP[1]=0;
                Data->PTStatus_DSP[2]=0;
                Data->CTStatus_DSP[0]=0;
                Data->CTStatus_DSP[1]=0;
                Data->CTStatus_DSP[2]=0;
            }
        }
        else
        {
            Data->PTStatus_DSP[0]=(buf.LineStatus[i].IsPTAOK[DSPMARK_1]== B_TRUE)?1:0;
            Data->PTStatus_DSP[1]=(buf.LineStatus[i].IsPTBOK[DSPMARK_1]== B_TRUE)?1:0;
            Data->PTStatus_DSP[2]=(buf.LineStatus[i].IsPTCOK[DSPMARK_1]== B_TRUE)?1:0;
            Data->CTStatus_DSP[0]=(buf.LineStatus[i].IsCTAOK[DSPMARK_1]== B_TRUE)?1:0;
            Data->CTStatus_DSP[1]=(buf.LineStatus[i].IsCTBOK[DSPMARK_1]== B_TRUE)?1:0;
            Data->CTStatus_DSP[2]=(buf.LineStatus[i].IsCTCOK[DSPMARK_1]== B_TRUE)?1:0;
        }
        break;
    }
    if(i == MainGlobalParam.LineCount)
    {
        Data->CodeSystem_DSP = 0;
        Data->InterRAM_DSP=0;
        Data->Timer_DSP=0;
        Data->interrupt_DSP =0;
        Data->Flash_DSP=0;
        Data->ExterRAM_DSP=0;
        Data->ADCheck_DSP=0;
        Data->PTStatus_DSP[0]=0;
        Data->PTStatus_DSP[1]=0;
        Data->PTStatus_DSP[2]=0;
        Data->CTStatus_DSP[0]=0;
        Data->CTStatus_DSP[1]=0;
        Data->CTStatus_DSP[2]=0;
    }
    Data->DataFlash_MCU = (buf.SysStatus.IsDFlashOK == B_TRUE)?1:0;
    Data->Ide_MCU =buf.SysStatus.FreeHdbSize;
    Data->LiunxFs_MCU = (buf.SysStatus.IsFSOK == B_TRUE)?1:0;
    Data->RamFree_MCU = buf.SysStatus.FreeMemSize;
    Data->System_MCU = (buf.SysStatus.IsSysOK== B_TRUE)?1:0;
    Data->Status_NET = (buf.SysStatus.IsNetLinkOK== B_TRUE)?1:0;
    
    PrlFrame->UserData.DataLen = sizeof(struct SelfCheck_LCD);
    return PRL_EXECUTE_OK;

}


int GetEventFilter(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
     
    BSTATUS *Data=(BSTATUS *)PrlFrame->UserData.Data;
    GetGlobalParam(GPT_EVENT_FILTER, Data);
    PrlFrame->UserData.DataLen = sizeof(BSTATUS)*EVENT_TYPE_COUNT_ALL;
    return PRL_EXECUTE_OK;
}

int SetEventFilter(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{ 
    BSTATUS *Data=(BSTATUS *)PrlFrame->UserData.Data;
    SetGlobalParam(GPT_EVENT_FILTER, Data);
    if (SaveSysParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}


int GetFaultFilter(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
     
    BSTATUS *Data=(BSTATUS *)PrlFrame->UserData.Data;
    GetGlobalParam(GPT_FAULT_FILTER, Data);
    PrlFrame->UserData.DataLen = sizeof(BSTATUS)*FAULT_TYPE_COUNT;
    return PRL_EXECUTE_OK;
}

int SetFaultFilter(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{ 
    BSTATUS *Data=(BSTATUS *)PrlFrame->UserData.Data;
    SetGlobalParam(GPT_FAULT_FILTER, Data);
    if (SaveSysParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}



int GetRecParamTE(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TRecWavParamTEvent *Data = (TRecWavParamTEvent *)PrlFrame->UserData.Data;
    GetGlobalParam(GPT_REC_WAV_PARAM_TE, Data);
    PrlFrame->UserData.DataLen = sizeof(TRecWavParamTEvent);
    return PRL_EXECUTE_OK;
    
}

int SetRecParamTE(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    TRecWavParamTEvent *Data=(TRecWavParamTEvent *)PrlFrame->UserData.Data;
    SetGlobalParam(GPT_REC_WAV_PARAM_TE, Data);
    if (SaveSysParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}



int GetNetworkSetting(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    struct NetworkSetting_LCD *Data = (struct NetworkSetting_LCD *)PrlFrame->UserData.Data;
    GetGlobalParam(GPT_MONITOR_ID, &Data->MonitorID);
    PrlFrame->UserData.DataLen = sizeof(struct NetworkSetting_LCD);
    return PRL_EXECUTE_OK;
}


int SetNetworkSetting(TPrlFrame *PrlFrame, void *Param1, void *Param2)
{
    struct NetworkSetting_LCD *Data = (struct NetworkSetting_LCD *)PrlFrame->UserData.Data;
    SetGlobalParam(GPT_MONITOR_ID, &Data->MonitorID);
    if (SaveSysParam() != B_TRUE)
    {
        return PRL_EXECUTE_FAILED;
    }
    SetIsParamModified(B_TRUE);
    return PRL_EXECUTE_OK;
}